xref: /openbmc/linux/sound/pci/hda/patch_realtek.c (revision b8bb76713ec50df2f11efee386e16f93d51e1076) 
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for ALC 260/880/882 codecs
5  *
6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7  *                    PeiSen Hou <pshou@realtek.com.tw>
8  *                    Takashi Iwai <tiwai@suse.de>
9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
10  *
11  *  This driver is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This driver is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
24  */
25 
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/pci.h>
30 #include <sound/core.h>
31 #include "hda_codec.h"
32 #include "hda_local.h"
33 #include "hda_beep.h"
34 
35 #define ALC880_FRONT_EVENT		0x01
36 #define ALC880_DCVOL_EVENT		0x02
37 #define ALC880_HP_EVENT			0x04
38 #define ALC880_MIC_EVENT		0x08
39 
40 /* ALC880 board config type */
41 enum {
42 	ALC880_3ST,
43 	ALC880_3ST_DIG,
44 	ALC880_5ST,
45 	ALC880_5ST_DIG,
46 	ALC880_W810,
47 	ALC880_Z71V,
48 	ALC880_6ST,
49 	ALC880_6ST_DIG,
50 	ALC880_F1734,
51 	ALC880_ASUS,
52 	ALC880_ASUS_DIG,
53 	ALC880_ASUS_W1V,
54 	ALC880_ASUS_DIG2,
55 	ALC880_FUJITSU,
56 	ALC880_UNIWILL_DIG,
57 	ALC880_UNIWILL,
58 	ALC880_UNIWILL_P53,
59 	ALC880_CLEVO,
60 	ALC880_TCL_S700,
61 	ALC880_LG,
62 	ALC880_LG_LW,
63 	ALC880_MEDION_RIM,
64 #ifdef CONFIG_SND_DEBUG
65 	ALC880_TEST,
66 #endif
67 	ALC880_AUTO,
68 	ALC880_MODEL_LAST /* last tag */
69 };
70 
71 /* ALC260 models */
72 enum {
73 	ALC260_BASIC,
74 	ALC260_HP,
75 	ALC260_HP_DC7600,
76 	ALC260_HP_3013,
77 	ALC260_FUJITSU_S702X,
78 	ALC260_ACER,
79 	ALC260_WILL,
80 	ALC260_REPLACER_672V,
81 	ALC260_FAVORIT100,
82 #ifdef CONFIG_SND_DEBUG
83 	ALC260_TEST,
84 #endif
85 	ALC260_AUTO,
86 	ALC260_MODEL_LAST /* last tag */
87 };
88 
89 /* ALC262 models */
90 enum {
91 	ALC262_BASIC,
92 	ALC262_HIPPO,
93 	ALC262_HIPPO_1,
94 	ALC262_FUJITSU,
95 	ALC262_HP_BPC,
96 	ALC262_HP_BPC_D7000_WL,
97 	ALC262_HP_BPC_D7000_WF,
98 	ALC262_HP_TC_T5735,
99 	ALC262_HP_RP5700,
100 	ALC262_BENQ_ED8,
101 	ALC262_SONY_ASSAMD,
102 	ALC262_BENQ_T31,
103 	ALC262_ULTRA,
104 	ALC262_LENOVO_3000,
105 	ALC262_NEC,
106 	ALC262_TOSHIBA_S06,
107 	ALC262_TOSHIBA_RX1,
108 	ALC262_TYAN,
109 	ALC262_AUTO,
110 	ALC262_MODEL_LAST /* last tag */
111 };
112 
113 /* ALC268 models */
114 enum {
115 	ALC267_QUANTA_IL1,
116 	ALC268_3ST,
117 	ALC268_TOSHIBA,
118 	ALC268_ACER,
119 	ALC268_ACER_DMIC,
120 	ALC268_ACER_ASPIRE_ONE,
121 	ALC268_DELL,
122 	ALC268_ZEPTO,
123 #ifdef CONFIG_SND_DEBUG
124 	ALC268_TEST,
125 #endif
126 	ALC268_AUTO,
127 	ALC268_MODEL_LAST /* last tag */
128 };
129 
130 /* ALC269 models */
131 enum {
132 	ALC269_BASIC,
133 	ALC269_QUANTA_FL1,
134 	ALC269_ASUS_EEEPC_P703,
135 	ALC269_ASUS_EEEPC_P901,
136 	ALC269_FUJITSU,
137 	ALC269_LIFEBOOK,
138 	ALC269_AUTO,
139 	ALC269_MODEL_LAST /* last tag */
140 };
141 
142 /* ALC861 models */
143 enum {
144 	ALC861_3ST,
145 	ALC660_3ST,
146 	ALC861_3ST_DIG,
147 	ALC861_6ST_DIG,
148 	ALC861_UNIWILL_M31,
149 	ALC861_TOSHIBA,
150 	ALC861_ASUS,
151 	ALC861_ASUS_LAPTOP,
152 	ALC861_AUTO,
153 	ALC861_MODEL_LAST,
154 };
155 
156 /* ALC861-VD models */
157 enum {
158 	ALC660VD_3ST,
159 	ALC660VD_3ST_DIG,
160 	ALC660VD_ASUS_V1S,
161 	ALC861VD_3ST,
162 	ALC861VD_3ST_DIG,
163 	ALC861VD_6ST_DIG,
164 	ALC861VD_LENOVO,
165 	ALC861VD_DALLAS,
166 	ALC861VD_HP,
167 	ALC861VD_AUTO,
168 	ALC861VD_MODEL_LAST,
169 };
170 
171 /* ALC662 models */
172 enum {
173 	ALC662_3ST_2ch_DIG,
174 	ALC662_3ST_6ch_DIG,
175 	ALC662_3ST_6ch,
176 	ALC662_5ST_DIG,
177 	ALC662_LENOVO_101E,
178 	ALC662_ASUS_EEEPC_P701,
179 	ALC662_ASUS_EEEPC_EP20,
180 	ALC663_ASUS_M51VA,
181 	ALC663_ASUS_G71V,
182 	ALC663_ASUS_H13,
183 	ALC663_ASUS_G50V,
184 	ALC662_ECS,
185 	ALC663_ASUS_MODE1,
186 	ALC662_ASUS_MODE2,
187 	ALC663_ASUS_MODE3,
188 	ALC663_ASUS_MODE4,
189 	ALC663_ASUS_MODE5,
190 	ALC663_ASUS_MODE6,
191 	ALC662_AUTO,
192 	ALC662_MODEL_LAST,
193 };
194 
195 /* ALC882 models */
196 enum {
197 	ALC882_3ST_DIG,
198 	ALC882_6ST_DIG,
199 	ALC882_ARIMA,
200 	ALC882_W2JC,
201 	ALC882_TARGA,
202 	ALC882_ASUS_A7J,
203 	ALC882_ASUS_A7M,
204 	ALC885_MACPRO,
205 	ALC885_MBP3,
206 	ALC885_IMAC24,
207 	ALC882_AUTO,
208 	ALC882_MODEL_LAST,
209 };
210 
211 /* ALC883 models */
212 enum {
213 	ALC883_3ST_2ch_DIG,
214 	ALC883_3ST_6ch_DIG,
215 	ALC883_3ST_6ch,
216 	ALC883_6ST_DIG,
217 	ALC883_TARGA_DIG,
218 	ALC883_TARGA_2ch_DIG,
219 	ALC883_ACER,
220 	ALC883_ACER_ASPIRE,
221 	ALC888_ACER_ASPIRE_4930G,
222 	ALC883_MEDION,
223 	ALC883_MEDION_MD2,
224 	ALC883_LAPTOP_EAPD,
225 	ALC883_LENOVO_101E_2ch,
226 	ALC883_LENOVO_NB0763,
227 	ALC888_LENOVO_MS7195_DIG,
228 	ALC888_LENOVO_SKY,
229 	ALC883_HAIER_W66,
230 	ALC888_3ST_HP,
231 	ALC888_6ST_DELL,
232 	ALC883_MITAC,
233 	ALC883_CLEVO_M720,
234 	ALC883_FUJITSU_PI2515,
235 	ALC888_FUJITSU_XA3530,
236 	ALC883_3ST_6ch_INTEL,
237 	ALC888_ASUS_M90V,
238 	ALC888_ASUS_EEE1601,
239 	ALC1200_ASUS_P5Q,
240 	ALC883_AUTO,
241 	ALC883_MODEL_LAST,
242 };
243 
244 /* styles of capture selection */
245 enum {
246 	CAPT_MUX = 0,	/* only mux based */
247 	CAPT_MIX,	/* only mixer based */
248 	CAPT_1MUX_MIX,	/* first mux and other mixers */
249 };
250 
251 /* for GPIO Poll */
252 #define GPIO_MASK	0x03
253 
254 struct alc_spec {
255 	/* codec parameterization */
256 	struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
257 	unsigned int num_mixers;
258 	struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
259 	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
260 
261 	const struct hda_verb *init_verbs[5];	/* initialization verbs
262 						 * don't forget NULL
263 						 * termination!
264 						 */
265 	unsigned int num_init_verbs;
266 
267 	char *stream_name_analog;	/* analog PCM stream */
268 	struct hda_pcm_stream *stream_analog_playback;
269 	struct hda_pcm_stream *stream_analog_capture;
270 	struct hda_pcm_stream *stream_analog_alt_playback;
271 	struct hda_pcm_stream *stream_analog_alt_capture;
272 
273 	char *stream_name_digital;	/* digital PCM stream */
274 	struct hda_pcm_stream *stream_digital_playback;
275 	struct hda_pcm_stream *stream_digital_capture;
276 
277 	/* playback */
278 	struct hda_multi_out multiout;	/* playback set-up
279 					 * max_channels, dacs must be set
280 					 * dig_out_nid and hp_nid are optional
281 					 */
282 	hda_nid_t alt_dac_nid;
283 	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
284 	int dig_out_type;
285 
286 	/* capture */
287 	unsigned int num_adc_nids;
288 	hda_nid_t *adc_nids;
289 	hda_nid_t *capsrc_nids;
290 	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
291 	int capture_style;		/* capture style (CAPT_*) */
292 
293 	/* capture source */
294 	unsigned int num_mux_defs;
295 	const struct hda_input_mux *input_mux;
296 	unsigned int cur_mux[3];
297 
298 	/* channel model */
299 	const struct hda_channel_mode *channel_mode;
300 	int num_channel_mode;
301 	int need_dac_fix;
302 
303 	/* PCM information */
304 	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
305 
306 	/* dynamic controls, init_verbs and input_mux */
307 	struct auto_pin_cfg autocfg;
308 	struct snd_array kctls;
309 	struct hda_input_mux private_imux[3];
310 	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
311 
312 	/* hooks */
313 	void (*init_hook)(struct hda_codec *codec);
314 	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
315 
316 	/* for pin sensing */
317 	unsigned int sense_updated: 1;
318 	unsigned int jack_present: 1;
319 	unsigned int master_sw: 1;
320 
321 	/* other flags */
322 	unsigned int no_analog :1; /* digital I/O only */
323 
324 	/* for virtual master */
325 	hda_nid_t vmaster_nid;
326 #ifdef CONFIG_SND_HDA_POWER_SAVE
327 	struct hda_loopback_check loopback;
328 #endif
329 
330 	/* for PLL fix */
331 	hda_nid_t pll_nid;
332 	unsigned int pll_coef_idx, pll_coef_bit;
333 };
334 
335 /*
336  * configuration template - to be copied to the spec instance
337  */
338 struct alc_config_preset {
339 	struct snd_kcontrol_new *mixers[5]; /* should be identical size
340 					     * with spec
341 					     */
342 	struct snd_kcontrol_new *cap_mixer; /* capture mixer */
343 	const struct hda_verb *init_verbs[5];
344 	unsigned int num_dacs;
345 	hda_nid_t *dac_nids;
346 	hda_nid_t dig_out_nid;		/* optional */
347 	hda_nid_t hp_nid;		/* optional */
348 	hda_nid_t *slave_dig_outs;
349 	unsigned int num_adc_nids;
350 	hda_nid_t *adc_nids;
351 	hda_nid_t *capsrc_nids;
352 	hda_nid_t dig_in_nid;
353 	unsigned int num_channel_mode;
354 	const struct hda_channel_mode *channel_mode;
355 	int need_dac_fix;
356 	unsigned int num_mux_defs;
357 	const struct hda_input_mux *input_mux;
358 	void (*unsol_event)(struct hda_codec *, unsigned int);
359 	void (*init_hook)(struct hda_codec *);
360 #ifdef CONFIG_SND_HDA_POWER_SAVE
361 	struct hda_amp_list *loopbacks;
362 #endif
363 };
364 
365 
366 /*
367  * input MUX handling
368  */
369 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
370 			     struct snd_ctl_elem_info *uinfo)
371 {
372 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
373 	struct alc_spec *spec = codec->spec;
374 	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
375 	if (mux_idx >= spec->num_mux_defs)
376 		mux_idx = 0;
377 	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
378 }
379 
380 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
381 			    struct snd_ctl_elem_value *ucontrol)
382 {
383 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
384 	struct alc_spec *spec = codec->spec;
385 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
386 
387 	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
388 	return 0;
389 }
390 
391 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
392 			    struct snd_ctl_elem_value *ucontrol)
393 {
394 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
395 	struct alc_spec *spec = codec->spec;
396 	const struct hda_input_mux *imux;
397 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
398 	unsigned int mux_idx;
399 	hda_nid_t nid = spec->capsrc_nids ?
400 		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
401 
402 	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
403 	imux = &spec->input_mux[mux_idx];
404 
405 	if (spec->capture_style &&
406 	    !(spec->capture_style == CAPT_1MUX_MIX && !adc_idx)) {
407 		/* Matrix-mixer style (e.g. ALC882) */
408 		unsigned int *cur_val = &spec->cur_mux[adc_idx];
409 		unsigned int i, idx;
410 
411 		idx = ucontrol->value.enumerated.item[0];
412 		if (idx >= imux->num_items)
413 			idx = imux->num_items - 1;
414 		if (*cur_val == idx)
415 			return 0;
416 		for (i = 0; i < imux->num_items; i++) {
417 			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
418 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
419 						 imux->items[i].index,
420 						 HDA_AMP_MUTE, v);
421 		}
422 		*cur_val = idx;
423 		return 1;
424 	} else {
425 		/* MUX style (e.g. ALC880) */
426 		return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
427 					     &spec->cur_mux[adc_idx]);
428 	}
429 }
430 
431 /*
432  * channel mode setting
433  */
434 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
435 			    struct snd_ctl_elem_info *uinfo)
436 {
437 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
438 	struct alc_spec *spec = codec->spec;
439 	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
440 				    spec->num_channel_mode);
441 }
442 
443 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
444 			   struct snd_ctl_elem_value *ucontrol)
445 {
446 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
447 	struct alc_spec *spec = codec->spec;
448 	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
449 				   spec->num_channel_mode,
450 				   spec->multiout.max_channels);
451 }
452 
453 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
454 			   struct snd_ctl_elem_value *ucontrol)
455 {
456 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
457 	struct alc_spec *spec = codec->spec;
458 	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
459 				      spec->num_channel_mode,
460 				      &spec->multiout.max_channels);
461 	if (err >= 0 && spec->need_dac_fix)
462 		spec->multiout.num_dacs = spec->multiout.max_channels / 2;
463 	return err;
464 }
465 
466 /*
467  * Control the mode of pin widget settings via the mixer.  "pc" is used
468  * instead of "%" to avoid consequences of accidently treating the % as
469  * being part of a format specifier.  Maximum allowed length of a value is
470  * 63 characters plus NULL terminator.
471  *
472  * Note: some retasking pin complexes seem to ignore requests for input
473  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
474  * are requested.  Therefore order this list so that this behaviour will not
475  * cause problems when mixer clients move through the enum sequentially.
476  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
477  * March 2006.
478  */
479 static char *alc_pin_mode_names[] = {
480 	"Mic 50pc bias", "Mic 80pc bias",
481 	"Line in", "Line out", "Headphone out",
482 };
483 static unsigned char alc_pin_mode_values[] = {
484 	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
485 };
486 /* The control can present all 5 options, or it can limit the options based
487  * in the pin being assumed to be exclusively an input or an output pin.  In
488  * addition, "input" pins may or may not process the mic bias option
489  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
490  * accept requests for bias as of chip versions up to March 2006) and/or
491  * wiring in the computer.
492  */
493 #define ALC_PIN_DIR_IN              0x00
494 #define ALC_PIN_DIR_OUT             0x01
495 #define ALC_PIN_DIR_INOUT           0x02
496 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
497 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
498 
499 /* Info about the pin modes supported by the different pin direction modes.
500  * For each direction the minimum and maximum values are given.
501  */
502 static signed char alc_pin_mode_dir_info[5][2] = {
503 	{ 0, 2 },    /* ALC_PIN_DIR_IN */
504 	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
505 	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
506 	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
507 	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
508 };
509 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
510 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
511 #define alc_pin_mode_n_items(_dir) \
512 	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
513 
514 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
515 			     struct snd_ctl_elem_info *uinfo)
516 {
517 	unsigned int item_num = uinfo->value.enumerated.item;
518 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
519 
520 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
521 	uinfo->count = 1;
522 	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
523 
524 	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
525 		item_num = alc_pin_mode_min(dir);
526 	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
527 	return 0;
528 }
529 
530 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
531 			    struct snd_ctl_elem_value *ucontrol)
532 {
533 	unsigned int i;
534 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
535 	hda_nid_t nid = kcontrol->private_value & 0xffff;
536 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
537 	long *valp = ucontrol->value.integer.value;
538 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
539 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
540 						 0x00);
541 
542 	/* Find enumerated value for current pinctl setting */
543 	i = alc_pin_mode_min(dir);
544 	while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
545 		i++;
546 	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
547 	return 0;
548 }
549 
550 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
551 			    struct snd_ctl_elem_value *ucontrol)
552 {
553 	signed int change;
554 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
555 	hda_nid_t nid = kcontrol->private_value & 0xffff;
556 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
557 	long val = *ucontrol->value.integer.value;
558 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
559 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
560 						 0x00);
561 
562 	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
563 		val = alc_pin_mode_min(dir);
564 
565 	change = pinctl != alc_pin_mode_values[val];
566 	if (change) {
567 		/* Set pin mode to that requested */
568 		snd_hda_codec_write_cache(codec, nid, 0,
569 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
570 					  alc_pin_mode_values[val]);
571 
572 		/* Also enable the retasking pin's input/output as required
573 		 * for the requested pin mode.  Enum values of 2 or less are
574 		 * input modes.
575 		 *
576 		 * Dynamically switching the input/output buffers probably
577 		 * reduces noise slightly (particularly on input) so we'll
578 		 * do it.  However, having both input and output buffers
579 		 * enabled simultaneously doesn't seem to be problematic if
580 		 * this turns out to be necessary in the future.
581 		 */
582 		if (val <= 2) {
583 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
584 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
585 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
586 						 HDA_AMP_MUTE, 0);
587 		} else {
588 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
589 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
590 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
591 						 HDA_AMP_MUTE, 0);
592 		}
593 	}
594 	return change;
595 }
596 
597 #define ALC_PIN_MODE(xname, nid, dir) \
598 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
599 	  .info = alc_pin_mode_info, \
600 	  .get = alc_pin_mode_get, \
601 	  .put = alc_pin_mode_put, \
602 	  .private_value = nid | (dir<<16) }
603 
604 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
605  * together using a mask with more than one bit set.  This control is
606  * currently used only by the ALC260 test model.  At this stage they are not
607  * needed for any "production" models.
608  */
609 #ifdef CONFIG_SND_DEBUG
610 #define alc_gpio_data_info	snd_ctl_boolean_mono_info
611 
612 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
613 			     struct snd_ctl_elem_value *ucontrol)
614 {
615 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
616 	hda_nid_t nid = kcontrol->private_value & 0xffff;
617 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
618 	long *valp = ucontrol->value.integer.value;
619 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
620 					      AC_VERB_GET_GPIO_DATA, 0x00);
621 
622 	*valp = (val & mask) != 0;
623 	return 0;
624 }
625 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
626 			     struct snd_ctl_elem_value *ucontrol)
627 {
628 	signed int change;
629 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
630 	hda_nid_t nid = kcontrol->private_value & 0xffff;
631 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
632 	long val = *ucontrol->value.integer.value;
633 	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
634 						    AC_VERB_GET_GPIO_DATA,
635 						    0x00);
636 
637 	/* Set/unset the masked GPIO bit(s) as needed */
638 	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
639 	if (val == 0)
640 		gpio_data &= ~mask;
641 	else
642 		gpio_data |= mask;
643 	snd_hda_codec_write_cache(codec, nid, 0,
644 				  AC_VERB_SET_GPIO_DATA, gpio_data);
645 
646 	return change;
647 }
648 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
649 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
650 	  .info = alc_gpio_data_info, \
651 	  .get = alc_gpio_data_get, \
652 	  .put = alc_gpio_data_put, \
653 	  .private_value = nid | (mask<<16) }
654 #endif   /* CONFIG_SND_DEBUG */
655 
656 /* A switch control to allow the enabling of the digital IO pins on the
657  * ALC260.  This is incredibly simplistic; the intention of this control is
658  * to provide something in the test model allowing digital outputs to be
659  * identified if present.  If models are found which can utilise these
660  * outputs a more complete mixer control can be devised for those models if
661  * necessary.
662  */
663 #ifdef CONFIG_SND_DEBUG
664 #define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info
665 
666 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
667 			      struct snd_ctl_elem_value *ucontrol)
668 {
669 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
670 	hda_nid_t nid = kcontrol->private_value & 0xffff;
671 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
672 	long *valp = ucontrol->value.integer.value;
673 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
674 					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);
675 
676 	*valp = (val & mask) != 0;
677 	return 0;
678 }
679 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
680 			      struct snd_ctl_elem_value *ucontrol)
681 {
682 	signed int change;
683 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
684 	hda_nid_t nid = kcontrol->private_value & 0xffff;
685 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
686 	long val = *ucontrol->value.integer.value;
687 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
688 						    AC_VERB_GET_DIGI_CONVERT_1,
689 						    0x00);
690 
691 	/* Set/unset the masked control bit(s) as needed */
692 	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
693 	if (val==0)
694 		ctrl_data &= ~mask;
695 	else
696 		ctrl_data |= mask;
697 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
698 				  ctrl_data);
699 
700 	return change;
701 }
702 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
703 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
704 	  .info = alc_spdif_ctrl_info, \
705 	  .get = alc_spdif_ctrl_get, \
706 	  .put = alc_spdif_ctrl_put, \
707 	  .private_value = nid | (mask<<16) }
708 #endif   /* CONFIG_SND_DEBUG */
709 
710 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
711  * Again, this is only used in the ALC26x test models to help identify when
712  * the EAPD line must be asserted for features to work.
713  */
714 #ifdef CONFIG_SND_DEBUG
715 #define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info
716 
717 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
718 			      struct snd_ctl_elem_value *ucontrol)
719 {
720 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
721 	hda_nid_t nid = kcontrol->private_value & 0xffff;
722 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
723 	long *valp = ucontrol->value.integer.value;
724 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
725 					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);
726 
727 	*valp = (val & mask) != 0;
728 	return 0;
729 }
730 
731 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
732 			      struct snd_ctl_elem_value *ucontrol)
733 {
734 	int change;
735 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
736 	hda_nid_t nid = kcontrol->private_value & 0xffff;
737 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
738 	long val = *ucontrol->value.integer.value;
739 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
740 						    AC_VERB_GET_EAPD_BTLENABLE,
741 						    0x00);
742 
743 	/* Set/unset the masked control bit(s) as needed */
744 	change = (!val ? 0 : mask) != (ctrl_data & mask);
745 	if (!val)
746 		ctrl_data &= ~mask;
747 	else
748 		ctrl_data |= mask;
749 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
750 				  ctrl_data);
751 
752 	return change;
753 }
754 
755 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
756 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
757 	  .info = alc_eapd_ctrl_info, \
758 	  .get = alc_eapd_ctrl_get, \
759 	  .put = alc_eapd_ctrl_put, \
760 	  .private_value = nid | (mask<<16) }
761 #endif   /* CONFIG_SND_DEBUG */
762 
763 /*
764  * set up the input pin config (depending on the given auto-pin type)
765  */
766 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
767 			      int auto_pin_type)
768 {
769 	unsigned int val = PIN_IN;
770 
771 	if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
772 		unsigned int pincap;
773 		pincap = snd_hda_query_pin_caps(codec, nid);
774 		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
775 		if (pincap & AC_PINCAP_VREF_80)
776 			val = PIN_VREF80;
777 	}
778 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
779 }
780 
781 /*
782  */
783 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
784 {
785 	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
786 		return;
787 	spec->mixers[spec->num_mixers++] = mix;
788 }
789 
790 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
791 {
792 	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
793 		return;
794 	spec->init_verbs[spec->num_init_verbs++] = verb;
795 }
796 
797 #ifdef CONFIG_PROC_FS
798 /*
799  * hook for proc
800  */
801 static void print_realtek_coef(struct snd_info_buffer *buffer,
802 			       struct hda_codec *codec, hda_nid_t nid)
803 {
804 	int coeff;
805 
806 	if (nid != 0x20)
807 		return;
808 	coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
809 	snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
810 	coeff = snd_hda_codec_read(codec, nid, 0,
811 				   AC_VERB_GET_COEF_INDEX, 0);
812 	snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
813 }
814 #else
815 #define print_realtek_coef	NULL
816 #endif
817 
818 /*
819  * set up from the preset table
820  */
821 static void setup_preset(struct alc_spec *spec,
822 			 const struct alc_config_preset *preset)
823 {
824 	int i;
825 
826 	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
827 		add_mixer(spec, preset->mixers[i]);
828 	spec->cap_mixer = preset->cap_mixer;
829 	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
830 	     i++)
831 		add_verb(spec, preset->init_verbs[i]);
832 
833 	spec->channel_mode = preset->channel_mode;
834 	spec->num_channel_mode = preset->num_channel_mode;
835 	spec->need_dac_fix = preset->need_dac_fix;
836 
837 	spec->multiout.max_channels = spec->channel_mode[0].channels;
838 
839 	spec->multiout.num_dacs = preset->num_dacs;
840 	spec->multiout.dac_nids = preset->dac_nids;
841 	spec->multiout.dig_out_nid = preset->dig_out_nid;
842 	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
843 	spec->multiout.hp_nid = preset->hp_nid;
844 
845 	spec->num_mux_defs = preset->num_mux_defs;
846 	if (!spec->num_mux_defs)
847 		spec->num_mux_defs = 1;
848 	spec->input_mux = preset->input_mux;
849 
850 	spec->num_adc_nids = preset->num_adc_nids;
851 	spec->adc_nids = preset->adc_nids;
852 	spec->capsrc_nids = preset->capsrc_nids;
853 	spec->dig_in_nid = preset->dig_in_nid;
854 
855 	spec->unsol_event = preset->unsol_event;
856 	spec->init_hook = preset->init_hook;
857 #ifdef CONFIG_SND_HDA_POWER_SAVE
858 	spec->loopback.amplist = preset->loopbacks;
859 #endif
860 }
861 
862 /* Enable GPIO mask and set output */
863 static struct hda_verb alc_gpio1_init_verbs[] = {
864 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
865 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
866 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
867 	{ }
868 };
869 
870 static struct hda_verb alc_gpio2_init_verbs[] = {
871 	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
872 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
873 	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
874 	{ }
875 };
876 
877 static struct hda_verb alc_gpio3_init_verbs[] = {
878 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
879 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
880 	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
881 	{ }
882 };
883 
884 /*
885  * Fix hardware PLL issue
886  * On some codecs, the analog PLL gating control must be off while
887  * the default value is 1.
888  */
889 static void alc_fix_pll(struct hda_codec *codec)
890 {
891 	struct alc_spec *spec = codec->spec;
892 	unsigned int val;
893 
894 	if (!spec->pll_nid)
895 		return;
896 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
897 			    spec->pll_coef_idx);
898 	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
899 				 AC_VERB_GET_PROC_COEF, 0);
900 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
901 			    spec->pll_coef_idx);
902 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
903 			    val & ~(1 << spec->pll_coef_bit));
904 }
905 
906 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
907 			     unsigned int coef_idx, unsigned int coef_bit)
908 {
909 	struct alc_spec *spec = codec->spec;
910 	spec->pll_nid = nid;
911 	spec->pll_coef_idx = coef_idx;
912 	spec->pll_coef_bit = coef_bit;
913 	alc_fix_pll(codec);
914 }
915 
916 static void alc_sku_automute(struct hda_codec *codec)
917 {
918 	struct alc_spec *spec = codec->spec;
919 	unsigned int present;
920 	unsigned int hp_nid = spec->autocfg.hp_pins[0];
921 	unsigned int sp_nid = spec->autocfg.speaker_pins[0];
922 
923 	/* need to execute and sync at first */
924 	snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
925 	present = snd_hda_codec_read(codec, hp_nid, 0,
926 				     AC_VERB_GET_PIN_SENSE, 0);
927 	spec->jack_present = (present & 0x80000000) != 0;
928 	snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
929 			    spec->jack_present ? 0 : PIN_OUT);
930 }
931 
932 #if 0 /* it's broken in some acses -- temporarily disabled */
933 static void alc_mic_automute(struct hda_codec *codec)
934 {
935 	struct alc_spec *spec = codec->spec;
936 	unsigned int present;
937 	unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
938 	unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
939 	unsigned int mix_nid = spec->capsrc_nids[0];
940 	unsigned int capsrc_idx_mic, capsrc_idx_fmic;
941 
942 	capsrc_idx_mic = mic_nid - 0x18;
943 	capsrc_idx_fmic = fmic_nid - 0x18;
944 	present = snd_hda_codec_read(codec, mic_nid, 0,
945 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
946 	snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
947 		    0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
948 	snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
949 		    0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
950 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
951 			 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
952 }
953 #else
954 #define alc_mic_automute(codec) do {} while(0) /* NOP */
955 #endif /* disabled */
956 
957 /* unsolicited event for HP jack sensing */
958 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
959 {
960 	if (codec->vendor_id == 0x10ec0880)
961 		res >>= 28;
962 	else
963 		res >>= 26;
964 	if (res == ALC880_HP_EVENT)
965 		alc_sku_automute(codec);
966 
967 	if (res == ALC880_MIC_EVENT)
968 		alc_mic_automute(codec);
969 }
970 
971 static void alc_inithook(struct hda_codec *codec)
972 {
973 	alc_sku_automute(codec);
974 	alc_mic_automute(codec);
975 }
976 
977 /* additional initialization for ALC888 variants */
978 static void alc888_coef_init(struct hda_codec *codec)
979 {
980 	unsigned int tmp;
981 
982 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
983 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
984 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
985 	if ((tmp & 0xf0) == 0x20)
986 		/* alc888S-VC */
987 		snd_hda_codec_read(codec, 0x20, 0,
988 				   AC_VERB_SET_PROC_COEF, 0x830);
989 	 else
990 		 /* alc888-VB */
991 		 snd_hda_codec_read(codec, 0x20, 0,
992 				    AC_VERB_SET_PROC_COEF, 0x3030);
993 }
994 
995 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
996  *	31 ~ 16 :	Manufacture ID
997  *	15 ~ 8	:	SKU ID
998  *	7  ~ 0	:	Assembly ID
999  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1000  */
1001 static void alc_subsystem_id(struct hda_codec *codec,
1002 			     unsigned int porta, unsigned int porte,
1003 			     unsigned int portd)
1004 {
1005 	unsigned int ass, tmp, i;
1006 	unsigned nid;
1007 	struct alc_spec *spec = codec->spec;
1008 
1009 	ass = codec->subsystem_id & 0xffff;
1010 	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1011 		goto do_sku;
1012 
1013 	/*
1014 	 * 31~30	: port conetcivity
1015 	 * 29~21	: reserve
1016 	 * 20		: PCBEEP input
1017 	 * 19~16	: Check sum (15:1)
1018 	 * 15~1		: Custom
1019 	 * 0		: override
1020 	*/
1021 	nid = 0x1d;
1022 	if (codec->vendor_id == 0x10ec0260)
1023 		nid = 0x17;
1024 	ass = snd_hda_codec_get_pincfg(codec, nid);
1025 	if (!(ass & 1) && !(ass & 0x100000))
1026 		return;
1027 	if ((ass >> 30) != 1)	/* no physical connection */
1028 		return;
1029 
1030 	/* check sum */
1031 	tmp = 0;
1032 	for (i = 1; i < 16; i++) {
1033 		if ((ass >> i) & 1)
1034 			tmp++;
1035 	}
1036 	if (((ass >> 16) & 0xf) != tmp)
1037 		return;
1038 do_sku:
1039 	/*
1040 	 * 0 : override
1041 	 * 1 :	Swap Jack
1042 	 * 2 : 0 --> Desktop, 1 --> Laptop
1043 	 * 3~5 : External Amplifier control
1044 	 * 7~6 : Reserved
1045 	*/
1046 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
1047 	switch (tmp) {
1048 	case 1:
1049 		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1050 		break;
1051 	case 3:
1052 		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1053 		break;
1054 	case 7:
1055 		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1056 		break;
1057 	case 5:	/* set EAPD output high */
1058 		switch (codec->vendor_id) {
1059 		case 0x10ec0260:
1060 			snd_hda_codec_write(codec, 0x0f, 0,
1061 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1062 			snd_hda_codec_write(codec, 0x10, 0,
1063 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1064 			break;
1065 		case 0x10ec0262:
1066 		case 0x10ec0267:
1067 		case 0x10ec0268:
1068 		case 0x10ec0269:
1069 		case 0x10ec0272:
1070 		case 0x10ec0660:
1071 		case 0x10ec0662:
1072 		case 0x10ec0663:
1073 		case 0x10ec0862:
1074 		case 0x10ec0889:
1075 			snd_hda_codec_write(codec, 0x14, 0,
1076 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1077 			snd_hda_codec_write(codec, 0x15, 0,
1078 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1079 			break;
1080 		}
1081 		switch (codec->vendor_id) {
1082 		case 0x10ec0260:
1083 			snd_hda_codec_write(codec, 0x1a, 0,
1084 					    AC_VERB_SET_COEF_INDEX, 7);
1085 			tmp = snd_hda_codec_read(codec, 0x1a, 0,
1086 						 AC_VERB_GET_PROC_COEF, 0);
1087 			snd_hda_codec_write(codec, 0x1a, 0,
1088 					    AC_VERB_SET_COEF_INDEX, 7);
1089 			snd_hda_codec_write(codec, 0x1a, 0,
1090 					    AC_VERB_SET_PROC_COEF,
1091 					    tmp | 0x2010);
1092 			break;
1093 		case 0x10ec0262:
1094 		case 0x10ec0880:
1095 		case 0x10ec0882:
1096 		case 0x10ec0883:
1097 		case 0x10ec0885:
1098 		case 0x10ec0887:
1099 		case 0x10ec0889:
1100 			snd_hda_codec_write(codec, 0x20, 0,
1101 					    AC_VERB_SET_COEF_INDEX, 7);
1102 			tmp = snd_hda_codec_read(codec, 0x20, 0,
1103 						 AC_VERB_GET_PROC_COEF, 0);
1104 			snd_hda_codec_write(codec, 0x20, 0,
1105 					    AC_VERB_SET_COEF_INDEX, 7);
1106 			snd_hda_codec_write(codec, 0x20, 0,
1107 					    AC_VERB_SET_PROC_COEF,
1108 					    tmp | 0x2010);
1109 			break;
1110 		case 0x10ec0888:
1111 			/*alc888_coef_init(codec);*/ /* called in alc_init() */
1112 			break;
1113 		case 0x10ec0267:
1114 		case 0x10ec0268:
1115 			snd_hda_codec_write(codec, 0x20, 0,
1116 					    AC_VERB_SET_COEF_INDEX, 7);
1117 			tmp = snd_hda_codec_read(codec, 0x20, 0,
1118 						 AC_VERB_GET_PROC_COEF, 0);
1119 			snd_hda_codec_write(codec, 0x20, 0,
1120 					    AC_VERB_SET_COEF_INDEX, 7);
1121 			snd_hda_codec_write(codec, 0x20, 0,
1122 					    AC_VERB_SET_PROC_COEF,
1123 					    tmp | 0x3000);
1124 			break;
1125 		}
1126 	default:
1127 		break;
1128 	}
1129 
1130 	/* is laptop or Desktop and enable the function "Mute internal speaker
1131 	 * when the external headphone out jack is plugged"
1132 	 */
1133 	if (!(ass & 0x8000))
1134 		return;
1135 	/*
1136 	 * 10~8 : Jack location
1137 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1138 	 * 14~13: Resvered
1139 	 * 15   : 1 --> enable the function "Mute internal speaker
1140 	 *	        when the external headphone out jack is plugged"
1141 	 */
1142 	if (!spec->autocfg.speaker_pins[0]) {
1143 		if (spec->autocfg.line_out_pins[0])
1144 			spec->autocfg.speaker_pins[0] =
1145 				spec->autocfg.line_out_pins[0];
1146 		else
1147 			return;
1148 	}
1149 
1150 	if (!spec->autocfg.hp_pins[0]) {
1151 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
1152 		if (tmp == 0)
1153 			spec->autocfg.hp_pins[0] = porta;
1154 		else if (tmp == 1)
1155 			spec->autocfg.hp_pins[0] = porte;
1156 		else if (tmp == 2)
1157 			spec->autocfg.hp_pins[0] = portd;
1158 		else
1159 			return;
1160 	}
1161 	if (spec->autocfg.hp_pins[0])
1162 		snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1163 			AC_VERB_SET_UNSOLICITED_ENABLE,
1164 			AC_USRSP_EN | ALC880_HP_EVENT);
1165 
1166 #if 0 /* it's broken in some acses -- temporarily disabled */
1167 	if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1168 		spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1169 		snd_hda_codec_write(codec,
1170 			spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1171 			AC_VERB_SET_UNSOLICITED_ENABLE,
1172 			AC_USRSP_EN | ALC880_MIC_EVENT);
1173 #endif /* disabled */
1174 
1175 	spec->unsol_event = alc_sku_unsol_event;
1176 }
1177 
1178 /*
1179  * Fix-up pin default configurations
1180  */
1181 
1182 struct alc_pincfg {
1183 	hda_nid_t nid;
1184 	u32 val;
1185 };
1186 
1187 static void alc_fix_pincfg(struct hda_codec *codec,
1188 			   const struct snd_pci_quirk *quirk,
1189 			   const struct alc_pincfg **pinfix)
1190 {
1191 	const struct alc_pincfg *cfg;
1192 
1193 	quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1194 	if (!quirk)
1195 		return;
1196 
1197 	cfg = pinfix[quirk->value];
1198 	for (; cfg->nid; cfg++)
1199 		snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1200 }
1201 
1202 /*
1203  * ALC888
1204  */
1205 
1206 /*
1207  * 2ch mode
1208  */
1209 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1210 /* Mic-in jack as mic in */
1211 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1212 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1213 /* Line-in jack as Line in */
1214 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1215 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1216 /* Line-Out as Front */
1217 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1218 	{ } /* end */
1219 };
1220 
1221 /*
1222  * 4ch mode
1223  */
1224 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1225 /* Mic-in jack as mic in */
1226 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1227 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1228 /* Line-in jack as Surround */
1229 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1230 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1231 /* Line-Out as Front */
1232 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1233 	{ } /* end */
1234 };
1235 
1236 /*
1237  * 6ch mode
1238  */
1239 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1240 /* Mic-in jack as CLFE */
1241 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1242 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1243 /* Line-in jack as Surround */
1244 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1245 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1246 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1247 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1248 	{ } /* end */
1249 };
1250 
1251 /*
1252  * 8ch mode
1253  */
1254 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1255 /* Mic-in jack as CLFE */
1256 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1257 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1258 /* Line-in jack as Surround */
1259 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1260 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1261 /* Line-Out as Side */
1262 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1263 	{ } /* end */
1264 };
1265 
1266 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1267 	{ 2, alc888_4ST_ch2_intel_init },
1268 	{ 4, alc888_4ST_ch4_intel_init },
1269 	{ 6, alc888_4ST_ch6_intel_init },
1270 	{ 8, alc888_4ST_ch8_intel_init },
1271 };
1272 
1273 /*
1274  * ALC888 Fujitsu Siemens Amillo xa3530
1275  */
1276 
1277 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1278 /* Front Mic: set to PIN_IN (empty by default) */
1279 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1280 /* Connect Internal HP to Front */
1281 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1282 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1283 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1284 /* Connect Bass HP to Front */
1285 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1286 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1287 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1288 /* Connect Line-Out side jack (SPDIF) to Side */
1289 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1290 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1291 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1292 /* Connect Mic jack to CLFE */
1293 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1294 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1295 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1296 /* Connect Line-in jack to Surround */
1297 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1298 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1299 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1300 /* Connect HP out jack to Front */
1301 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1302 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1303 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1304 /* Enable unsolicited event for HP jack and Line-out jack */
1305 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1306 	{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1307 	{}
1308 };
1309 
1310 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1311 {
1312 	unsigned int present;
1313 	unsigned int bits;
1314 	/* Line out presence */
1315 	present = snd_hda_codec_read(codec, 0x17, 0,
1316 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1317 	/* HP out presence */
1318 	present = present || snd_hda_codec_read(codec, 0x1b, 0,
1319 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1320 	bits = present ? HDA_AMP_MUTE : 0;
1321 	/* Toggle internal speakers muting */
1322 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1323 				 HDA_AMP_MUTE, bits);
1324 	/* Toggle internal bass muting */
1325 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1326 				 HDA_AMP_MUTE, bits);
1327 }
1328 
1329 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1330 		unsigned int res)
1331 {
1332 	if (res >> 26 == ALC880_HP_EVENT)
1333 		alc888_fujitsu_xa3530_automute(codec);
1334 }
1335 
1336 
1337 /*
1338  * ALC888 Acer Aspire 4930G model
1339  */
1340 
1341 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1342 /* Front Mic: set to PIN_IN (empty by default) */
1343 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1344 /* Unselect Front Mic by default in input mixer 3 */
1345 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1346 /* Enable unsolicited event for HP jack */
1347 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1348 /* Connect Internal HP to front */
1349 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1350 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1351 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1352 /* Connect HP out to front */
1353 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1354 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1355 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1356 	{ }
1357 };
1358 
1359 static struct hda_input_mux alc888_2_capture_sources[2] = {
1360 	/* Front mic only available on one ADC */
1361 	{
1362 		.num_items = 4,
1363 		.items = {
1364 			{ "Mic", 0x0 },
1365 			{ "Line", 0x2 },
1366 			{ "CD", 0x4 },
1367 			{ "Front Mic", 0xb },
1368 		},
1369 	},
1370 	{
1371 		.num_items = 3,
1372 		.items = {
1373 			{ "Mic", 0x0 },
1374 			{ "Line", 0x2 },
1375 			{ "CD", 0x4 },
1376 		},
1377 	}
1378 };
1379 
1380 static struct snd_kcontrol_new alc888_base_mixer[] = {
1381 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1382 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1383 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1384 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1385 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1386 		HDA_OUTPUT),
1387 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1388 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1389 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1390 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1391 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1392 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1393 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1394 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1395 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1396 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1397 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1398 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1399 	{ } /* end */
1400 };
1401 
1402 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1403 {
1404 	unsigned int present;
1405 	unsigned int bits;
1406 	present = snd_hda_codec_read(codec, 0x15, 0,
1407 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1408 	bits = present ? HDA_AMP_MUTE : 0;
1409 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1410 				 HDA_AMP_MUTE, bits);
1411 }
1412 
1413 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1414 		unsigned int res)
1415 {
1416 	if (res >> 26 == ALC880_HP_EVENT)
1417 		alc888_acer_aspire_4930g_automute(codec);
1418 }
1419 
1420 /*
1421  * ALC880 3-stack model
1422  *
1423  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1424  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1425  *                 F-Mic = 0x1b, HP = 0x19
1426  */
1427 
1428 static hda_nid_t alc880_dac_nids[4] = {
1429 	/* front, rear, clfe, rear_surr */
1430 	0x02, 0x05, 0x04, 0x03
1431 };
1432 
1433 static hda_nid_t alc880_adc_nids[3] = {
1434 	/* ADC0-2 */
1435 	0x07, 0x08, 0x09,
1436 };
1437 
1438 /* The datasheet says the node 0x07 is connected from inputs,
1439  * but it shows zero connection in the real implementation on some devices.
1440  * Note: this is a 915GAV bug, fixed on 915GLV
1441  */
1442 static hda_nid_t alc880_adc_nids_alt[2] = {
1443 	/* ADC1-2 */
1444 	0x08, 0x09,
1445 };
1446 
1447 #define ALC880_DIGOUT_NID	0x06
1448 #define ALC880_DIGIN_NID	0x0a
1449 
1450 static struct hda_input_mux alc880_capture_source = {
1451 	.num_items = 4,
1452 	.items = {
1453 		{ "Mic", 0x0 },
1454 		{ "Front Mic", 0x3 },
1455 		{ "Line", 0x2 },
1456 		{ "CD", 0x4 },
1457 	},
1458 };
1459 
1460 /* channel source setting (2/6 channel selection for 3-stack) */
1461 /* 2ch mode */
1462 static struct hda_verb alc880_threestack_ch2_init[] = {
1463 	/* set line-in to input, mute it */
1464 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1465 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1466 	/* set mic-in to input vref 80%, mute it */
1467 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1468 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1469 	{ } /* end */
1470 };
1471 
1472 /* 6ch mode */
1473 static struct hda_verb alc880_threestack_ch6_init[] = {
1474 	/* set line-in to output, unmute it */
1475 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477 	/* set mic-in to output, unmute it */
1478 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1480 	{ } /* end */
1481 };
1482 
1483 static struct hda_channel_mode alc880_threestack_modes[2] = {
1484 	{ 2, alc880_threestack_ch2_init },
1485 	{ 6, alc880_threestack_ch6_init },
1486 };
1487 
1488 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1489 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1490 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1491 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1492 	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1493 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1494 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1495 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1496 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1497 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1498 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1499 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1500 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1501 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1502 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1503 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1504 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1505 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1506 	{
1507 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1508 		.name = "Channel Mode",
1509 		.info = alc_ch_mode_info,
1510 		.get = alc_ch_mode_get,
1511 		.put = alc_ch_mode_put,
1512 	},
1513 	{ } /* end */
1514 };
1515 
1516 /* capture mixer elements */
1517 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1518 			    struct snd_ctl_elem_info *uinfo)
1519 {
1520 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1521 	struct alc_spec *spec = codec->spec;
1522 	int err;
1523 
1524 	mutex_lock(&codec->control_mutex);
1525 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1526 						      HDA_INPUT);
1527 	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1528 	mutex_unlock(&codec->control_mutex);
1529 	return err;
1530 }
1531 
1532 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1533 			   unsigned int size, unsigned int __user *tlv)
1534 {
1535 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536 	struct alc_spec *spec = codec->spec;
1537 	int err;
1538 
1539 	mutex_lock(&codec->control_mutex);
1540 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1541 						      HDA_INPUT);
1542 	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1543 	mutex_unlock(&codec->control_mutex);
1544 	return err;
1545 }
1546 
1547 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1548 			     struct snd_ctl_elem_value *ucontrol);
1549 
1550 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1551 				 struct snd_ctl_elem_value *ucontrol,
1552 				 getput_call_t func)
1553 {
1554 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1555 	struct alc_spec *spec = codec->spec;
1556 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1557 	int err;
1558 
1559 	mutex_lock(&codec->control_mutex);
1560 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1561 						      3, 0, HDA_INPUT);
1562 	err = func(kcontrol, ucontrol);
1563 	mutex_unlock(&codec->control_mutex);
1564 	return err;
1565 }
1566 
1567 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1568 			   struct snd_ctl_elem_value *ucontrol)
1569 {
1570 	return alc_cap_getput_caller(kcontrol, ucontrol,
1571 				     snd_hda_mixer_amp_volume_get);
1572 }
1573 
1574 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1575 			   struct snd_ctl_elem_value *ucontrol)
1576 {
1577 	return alc_cap_getput_caller(kcontrol, ucontrol,
1578 				     snd_hda_mixer_amp_volume_put);
1579 }
1580 
1581 /* capture mixer elements */
1582 #define alc_cap_sw_info		snd_ctl_boolean_stereo_info
1583 
1584 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1585 			  struct snd_ctl_elem_value *ucontrol)
1586 {
1587 	return alc_cap_getput_caller(kcontrol, ucontrol,
1588 				     snd_hda_mixer_amp_switch_get);
1589 }
1590 
1591 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1592 			  struct snd_ctl_elem_value *ucontrol)
1593 {
1594 	return alc_cap_getput_caller(kcontrol, ucontrol,
1595 				     snd_hda_mixer_amp_switch_put);
1596 }
1597 
1598 #define _DEFINE_CAPMIX(num) \
1599 	{ \
1600 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1601 		.name = "Capture Switch", \
1602 		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1603 		.count = num, \
1604 		.info = alc_cap_sw_info, \
1605 		.get = alc_cap_sw_get, \
1606 		.put = alc_cap_sw_put, \
1607 	}, \
1608 	{ \
1609 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1610 		.name = "Capture Volume", \
1611 		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1612 			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1613 			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1614 		.count = num, \
1615 		.info = alc_cap_vol_info, \
1616 		.get = alc_cap_vol_get, \
1617 		.put = alc_cap_vol_put, \
1618 		.tlv = { .c = alc_cap_vol_tlv }, \
1619 	}
1620 
1621 #define _DEFINE_CAPSRC(num) \
1622 	{ \
1623 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1624 		/* .name = "Capture Source", */ \
1625 		.name = "Input Source", \
1626 		.count = num, \
1627 		.info = alc_mux_enum_info, \
1628 		.get = alc_mux_enum_get, \
1629 		.put = alc_mux_enum_put, \
1630 	}
1631 
1632 #define DEFINE_CAPMIX(num) \
1633 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1634 	_DEFINE_CAPMIX(num),				      \
1635 	_DEFINE_CAPSRC(num),				      \
1636 	{ } /* end */					      \
1637 }
1638 
1639 #define DEFINE_CAPMIX_NOSRC(num) \
1640 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1641 	_DEFINE_CAPMIX(num),					    \
1642 	{ } /* end */						    \
1643 }
1644 
1645 /* up to three ADCs */
1646 DEFINE_CAPMIX(1);
1647 DEFINE_CAPMIX(2);
1648 DEFINE_CAPMIX(3);
1649 DEFINE_CAPMIX_NOSRC(1);
1650 DEFINE_CAPMIX_NOSRC(2);
1651 DEFINE_CAPMIX_NOSRC(3);
1652 
1653 /*
1654  * ALC880 5-stack model
1655  *
1656  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1657  *      Side = 0x02 (0xd)
1658  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1659  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1660  */
1661 
1662 /* additional mixers to alc880_three_stack_mixer */
1663 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1664 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1665 	HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1666 	{ } /* end */
1667 };
1668 
1669 /* channel source setting (6/8 channel selection for 5-stack) */
1670 /* 6ch mode */
1671 static struct hda_verb alc880_fivestack_ch6_init[] = {
1672 	/* set line-in to input, mute it */
1673 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1674 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1675 	{ } /* end */
1676 };
1677 
1678 /* 8ch mode */
1679 static struct hda_verb alc880_fivestack_ch8_init[] = {
1680 	/* set line-in to output, unmute it */
1681 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1682 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1683 	{ } /* end */
1684 };
1685 
1686 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1687 	{ 6, alc880_fivestack_ch6_init },
1688 	{ 8, alc880_fivestack_ch8_init },
1689 };
1690 
1691 
1692 /*
1693  * ALC880 6-stack model
1694  *
1695  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1696  *      Side = 0x05 (0x0f)
1697  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1698  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1699  */
1700 
1701 static hda_nid_t alc880_6st_dac_nids[4] = {
1702 	/* front, rear, clfe, rear_surr */
1703 	0x02, 0x03, 0x04, 0x05
1704 };
1705 
1706 static struct hda_input_mux alc880_6stack_capture_source = {
1707 	.num_items = 4,
1708 	.items = {
1709 		{ "Mic", 0x0 },
1710 		{ "Front Mic", 0x1 },
1711 		{ "Line", 0x2 },
1712 		{ "CD", 0x4 },
1713 	},
1714 };
1715 
1716 /* fixed 8-channels */
1717 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1718 	{ 8, NULL },
1719 };
1720 
1721 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1722 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1723 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1724 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1725 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1726 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1727 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1728 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1729 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1730 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1731 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1732 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1733 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1734 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1735 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1736 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1737 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1738 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1739 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1740 	{
1741 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1742 		.name = "Channel Mode",
1743 		.info = alc_ch_mode_info,
1744 		.get = alc_ch_mode_get,
1745 		.put = alc_ch_mode_put,
1746 	},
1747 	{ } /* end */
1748 };
1749 
1750 
1751 /*
1752  * ALC880 W810 model
1753  *
1754  * W810 has rear IO for:
1755  * Front (DAC 02)
1756  * Surround (DAC 03)
1757  * Center/LFE (DAC 04)
1758  * Digital out (06)
1759  *
1760  * The system also has a pair of internal speakers, and a headphone jack.
1761  * These are both connected to Line2 on the codec, hence to DAC 02.
1762  *
1763  * There is a variable resistor to control the speaker or headphone
1764  * volume. This is a hardware-only device without a software API.
1765  *
1766  * Plugging headphones in will disable the internal speakers. This is
1767  * implemented in hardware, not via the driver using jack sense. In
1768  * a similar fashion, plugging into the rear socket marked "front" will
1769  * disable both the speakers and headphones.
1770  *
1771  * For input, there's a microphone jack, and an "audio in" jack.
1772  * These may not do anything useful with this driver yet, because I
1773  * haven't setup any initialization verbs for these yet...
1774  */
1775 
1776 static hda_nid_t alc880_w810_dac_nids[3] = {
1777 	/* front, rear/surround, clfe */
1778 	0x02, 0x03, 0x04
1779 };
1780 
1781 /* fixed 6 channels */
1782 static struct hda_channel_mode alc880_w810_modes[1] = {
1783 	{ 6, NULL }
1784 };
1785 
1786 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1787 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1788 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1789 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1790 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1791 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1792 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1793 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1794 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1795 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1796 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1797 	{ } /* end */
1798 };
1799 
1800 
1801 /*
1802  * Z710V model
1803  *
1804  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1805  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1806  *                 Line = 0x1a
1807  */
1808 
1809 static hda_nid_t alc880_z71v_dac_nids[1] = {
1810 	0x02
1811 };
1812 #define ALC880_Z71V_HP_DAC	0x03
1813 
1814 /* fixed 2 channels */
1815 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1816 	{ 2, NULL }
1817 };
1818 
1819 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1820 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1821 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1822 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1823 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1824 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1825 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1826 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1827 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1828 	{ } /* end */
1829 };
1830 
1831 
1832 /*
1833  * ALC880 F1734 model
1834  *
1835  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1836  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1837  */
1838 
1839 static hda_nid_t alc880_f1734_dac_nids[1] = {
1840 	0x03
1841 };
1842 #define ALC880_F1734_HP_DAC	0x02
1843 
1844 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1845 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1846 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1847 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1848 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1849 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1850 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1851 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1852 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1853 	{ } /* end */
1854 };
1855 
1856 static struct hda_input_mux alc880_f1734_capture_source = {
1857 	.num_items = 2,
1858 	.items = {
1859 		{ "Mic", 0x1 },
1860 		{ "CD", 0x4 },
1861 	},
1862 };
1863 
1864 
1865 /*
1866  * ALC880 ASUS model
1867  *
1868  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1869  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1870  *  Mic = 0x18, Line = 0x1a
1871  */
1872 
1873 #define alc880_asus_dac_nids	alc880_w810_dac_nids	/* identical with w810 */
1874 #define alc880_asus_modes	alc880_threestack_modes	/* 2/6 channel mode */
1875 
1876 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1877 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1878 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1879 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1880 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1881 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1882 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1883 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1884 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1885 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1886 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1887 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1888 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1889 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1890 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1891 	{
1892 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1893 		.name = "Channel Mode",
1894 		.info = alc_ch_mode_info,
1895 		.get = alc_ch_mode_get,
1896 		.put = alc_ch_mode_put,
1897 	},
1898 	{ } /* end */
1899 };
1900 
1901 /*
1902  * ALC880 ASUS W1V model
1903  *
1904  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1905  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1906  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1907  */
1908 
1909 /* additional mixers to alc880_asus_mixer */
1910 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1911 	HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1912 	HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1913 	{ } /* end */
1914 };
1915 
1916 /* TCL S700 */
1917 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1918 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1919 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1920 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1921 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1922 	HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1923 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1924 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1925 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1926 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1927 	{ } /* end */
1928 };
1929 
1930 /* Uniwill */
1931 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1932 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1933 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1934 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1935 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1936 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1937 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1938 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1939 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1940 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1941 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1942 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1943 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1944 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1945 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1946 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1947 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1948 	{
1949 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1950 		.name = "Channel Mode",
1951 		.info = alc_ch_mode_info,
1952 		.get = alc_ch_mode_get,
1953 		.put = alc_ch_mode_put,
1954 	},
1955 	{ } /* end */
1956 };
1957 
1958 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1959 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1960 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1961 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1962 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1963 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1964 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1965 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1966 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1967 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1968 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1969 	{ } /* end */
1970 };
1971 
1972 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1973 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1974 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1975 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1976 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1977 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1978 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1979 	{ } /* end */
1980 };
1981 
1982 /*
1983  * virtual master controls
1984  */
1985 
1986 /*
1987  * slave controls for virtual master
1988  */
1989 static const char *alc_slave_vols[] = {
1990 	"Front Playback Volume",
1991 	"Surround Playback Volume",
1992 	"Center Playback Volume",
1993 	"LFE Playback Volume",
1994 	"Side Playback Volume",
1995 	"Headphone Playback Volume",
1996 	"Speaker Playback Volume",
1997 	"Mono Playback Volume",
1998 	"Line-Out Playback Volume",
1999 	"PCM Playback Volume",
2000 	NULL,
2001 };
2002 
2003 static const char *alc_slave_sws[] = {
2004 	"Front Playback Switch",
2005 	"Surround Playback Switch",
2006 	"Center Playback Switch",
2007 	"LFE Playback Switch",
2008 	"Side Playback Switch",
2009 	"Headphone Playback Switch",
2010 	"Speaker Playback Switch",
2011 	"Mono Playback Switch",
2012 	"IEC958 Playback Switch",
2013 	NULL,
2014 };
2015 
2016 /*
2017  * build control elements
2018  */
2019 
2020 static void alc_free_kctls(struct hda_codec *codec);
2021 
2022 /* additional beep mixers; the actual parameters are overwritten at build */
2023 static struct snd_kcontrol_new alc_beep_mixer[] = {
2024 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2025 	HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2026 	{ } /* end */
2027 };
2028 
2029 static int alc_build_controls(struct hda_codec *codec)
2030 {
2031 	struct alc_spec *spec = codec->spec;
2032 	int err;
2033 	int i;
2034 
2035 	for (i = 0; i < spec->num_mixers; i++) {
2036 		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2037 		if (err < 0)
2038 			return err;
2039 	}
2040 	if (spec->cap_mixer) {
2041 		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2042 		if (err < 0)
2043 			return err;
2044 	}
2045 	if (spec->multiout.dig_out_nid) {
2046 		err = snd_hda_create_spdif_out_ctls(codec,
2047 						    spec->multiout.dig_out_nid);
2048 		if (err < 0)
2049 			return err;
2050 		if (!spec->no_analog) {
2051 			err = snd_hda_create_spdif_share_sw(codec,
2052 							    &spec->multiout);
2053 			if (err < 0)
2054 				return err;
2055 			spec->multiout.share_spdif = 1;
2056 		}
2057 	}
2058 	if (spec->dig_in_nid) {
2059 		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2060 		if (err < 0)
2061 			return err;
2062 	}
2063 
2064 	/* create beep controls if needed */
2065 	if (spec->beep_amp) {
2066 		struct snd_kcontrol_new *knew;
2067 		for (knew = alc_beep_mixer; knew->name; knew++) {
2068 			struct snd_kcontrol *kctl;
2069 			kctl = snd_ctl_new1(knew, codec);
2070 			if (!kctl)
2071 				return -ENOMEM;
2072 			kctl->private_value = spec->beep_amp;
2073 			err = snd_hda_ctl_add(codec, kctl);
2074 			if (err < 0)
2075 				return err;
2076 		}
2077 	}
2078 
2079 	/* if we have no master control, let's create it */
2080 	if (!spec->no_analog &&
2081 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2082 		unsigned int vmaster_tlv[4];
2083 		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2084 					HDA_OUTPUT, vmaster_tlv);
2085 		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2086 					  vmaster_tlv, alc_slave_vols);
2087 		if (err < 0)
2088 			return err;
2089 	}
2090 	if (!spec->no_analog &&
2091 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2092 		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2093 					  NULL, alc_slave_sws);
2094 		if (err < 0)
2095 			return err;
2096 	}
2097 
2098 	alc_free_kctls(codec); /* no longer needed */
2099 	return 0;
2100 }
2101 
2102 
2103 /*
2104  * initialize the codec volumes, etc
2105  */
2106 
2107 /*
2108  * generic initialization of ADC, input mixers and output mixers
2109  */
2110 static struct hda_verb alc880_volume_init_verbs[] = {
2111 	/*
2112 	 * Unmute ADC0-2 and set the default input to mic-in
2113 	 */
2114 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2115 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2116 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2117 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2118 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2119 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2120 
2121 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2122 	 * mixer widget
2123 	 * Note: PASD motherboards uses the Line In 2 as the input for front
2124 	 * panel mic (mic 2)
2125 	 */
2126 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2127 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2128 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2129 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2130 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2131 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2132 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2133 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2134 
2135 	/*
2136 	 * Set up output mixers (0x0c - 0x0f)
2137 	 */
2138 	/* set vol=0 to output mixers */
2139 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2140 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2141 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2142 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2143 	/* set up input amps for analog loopback */
2144 	/* Amp Indices: DAC = 0, mixer = 1 */
2145 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2146 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2147 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2148 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2149 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2150 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2151 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2152 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2153 
2154 	{ }
2155 };
2156 
2157 /*
2158  * 3-stack pin configuration:
2159  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2160  */
2161 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2162 	/*
2163 	 * preset connection lists of input pins
2164 	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2165 	 */
2166 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2167 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2168 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2169 
2170 	/*
2171 	 * Set pin mode and muting
2172 	 */
2173 	/* set front pin widgets 0x14 for output */
2174 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2175 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2176 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2177 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2178 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2179 	/* Mic2 (as headphone out) for HP output */
2180 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2181 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2182 	/* Line In pin widget for input */
2183 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2184 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2185 	/* Line2 (as front mic) pin widget for input and vref at 80% */
2186 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2187 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2188 	/* CD pin widget for input */
2189 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2190 
2191 	{ }
2192 };
2193 
2194 /*
2195  * 5-stack pin configuration:
2196  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2197  * line-in/side = 0x1a, f-mic = 0x1b
2198  */
2199 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2200 	/*
2201 	 * preset connection lists of input pins
2202 	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2203 	 */
2204 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2205 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2206 
2207 	/*
2208 	 * Set pin mode and muting
2209 	 */
2210 	/* set pin widgets 0x14-0x17 for output */
2211 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2212 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2213 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2214 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2215 	/* unmute pins for output (no gain on this amp) */
2216 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2217 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2218 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2219 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2220 
2221 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2222 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2223 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2224 	/* Mic2 (as headphone out) for HP output */
2225 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2226 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2227 	/* Line In pin widget for input */
2228 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2229 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2230 	/* Line2 (as front mic) pin widget for input and vref at 80% */
2231 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2232 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2233 	/* CD pin widget for input */
2234 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2235 
2236 	{ }
2237 };
2238 
2239 /*
2240  * W810 pin configuration:
2241  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2242  */
2243 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2244 	/* hphone/speaker input selector: front DAC */
2245 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2246 
2247 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2248 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2249 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2250 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2251 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2252 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2253 
2254 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2255 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2256 
2257 	{ }
2258 };
2259 
2260 /*
2261  * Z71V pin configuration:
2262  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2263  */
2264 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2265 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2266 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2267 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2268 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2269 
2270 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2271 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2272 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2273 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2274 
2275 	{ }
2276 };
2277 
2278 /*
2279  * 6-stack pin configuration:
2280  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2281  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2282  */
2283 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2284 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2285 
2286 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2287 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2288 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2289 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2290 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2291 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2292 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2293 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2294 
2295 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2296 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2297 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2298 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2299 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2300 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2301 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2302 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2303 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2304 
2305 	{ }
2306 };
2307 
2308 /*
2309  * Uniwill pin configuration:
2310  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2311  * line = 0x1a
2312  */
2313 static struct hda_verb alc880_uniwill_init_verbs[] = {
2314 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2315 
2316 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2317 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2318 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2319 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2320 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2321 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2322 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2323 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2324 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2325 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2326 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2327 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2328 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2329 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2330 
2331 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2332 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2333 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2334 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2335 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2336 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2337 	/* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2338 	/* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2339 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2340 
2341 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2342 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2343 
2344 	{ }
2345 };
2346 
2347 /*
2348 * Uniwill P53
2349 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2350  */
2351 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2352 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2353 
2354 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2355 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2356 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2357 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2358 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2359 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2360 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2361 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2362 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2363 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2364 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2365 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2366 
2367 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2368 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2369 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2370 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2371 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2372 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2373 
2374 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2375 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2376 
2377 	{ }
2378 };
2379 
2380 static struct hda_verb alc880_beep_init_verbs[] = {
2381 	{ 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2382 	{ }
2383 };
2384 
2385 /* toggle speaker-output according to the hp-jack state */
2386 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2387 {
2388  	unsigned int present;
2389 	unsigned char bits;
2390 
2391  	present = snd_hda_codec_read(codec, 0x14, 0,
2392 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2393 	bits = present ? HDA_AMP_MUTE : 0;
2394 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2395 				 HDA_AMP_MUTE, bits);
2396 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2397 				 HDA_AMP_MUTE, bits);
2398 }
2399 
2400 /* auto-toggle front mic */
2401 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2402 {
2403  	unsigned int present;
2404 	unsigned char bits;
2405 
2406 	present = snd_hda_codec_read(codec, 0x18, 0,
2407 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2408 	bits = present ? HDA_AMP_MUTE : 0;
2409 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2410 }
2411 
2412 static void alc880_uniwill_automute(struct hda_codec *codec)
2413 {
2414 	alc880_uniwill_hp_automute(codec);
2415 	alc880_uniwill_mic_automute(codec);
2416 }
2417 
2418 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2419 				       unsigned int res)
2420 {
2421 	/* Looks like the unsol event is incompatible with the standard
2422 	 * definition.  4bit tag is placed at 28 bit!
2423 	 */
2424 	switch (res >> 28) {
2425 	case ALC880_HP_EVENT:
2426 		alc880_uniwill_hp_automute(codec);
2427 		break;
2428 	case ALC880_MIC_EVENT:
2429 		alc880_uniwill_mic_automute(codec);
2430 		break;
2431 	}
2432 }
2433 
2434 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2435 {
2436  	unsigned int present;
2437 	unsigned char bits;
2438 
2439  	present = snd_hda_codec_read(codec, 0x14, 0,
2440 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2441 	bits = present ? HDA_AMP_MUTE : 0;
2442 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2443 }
2444 
2445 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2446 {
2447 	unsigned int present;
2448 
2449 	present = snd_hda_codec_read(codec, 0x21, 0,
2450 				     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2451 	present &= HDA_AMP_VOLMASK;
2452 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2453 				 HDA_AMP_VOLMASK, present);
2454 	snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2455 				 HDA_AMP_VOLMASK, present);
2456 }
2457 
2458 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2459 					   unsigned int res)
2460 {
2461 	/* Looks like the unsol event is incompatible with the standard
2462 	 * definition.  4bit tag is placed at 28 bit!
2463 	 */
2464 	if ((res >> 28) == ALC880_HP_EVENT)
2465 		alc880_uniwill_p53_hp_automute(codec);
2466 	if ((res >> 28) == ALC880_DCVOL_EVENT)
2467 		alc880_uniwill_p53_dcvol_automute(codec);
2468 }
2469 
2470 /*
2471  * F1734 pin configuration:
2472  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2473  */
2474 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2475 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2476 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2477 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2478 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2479 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2480 
2481 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2482 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2483 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2484 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2485 
2486 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2487 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2488 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2489 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2490 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2491 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2492 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2493 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2494 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2495 
2496 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2497 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2498 
2499 	{ }
2500 };
2501 
2502 /*
2503  * ASUS pin configuration:
2504  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2505  */
2506 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2507 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2508 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2509 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2510 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2511 
2512 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2513 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2514 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2515 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2516 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2517 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2518 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2519 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2520 
2521 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2522 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2523 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2524 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2525 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2526 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2527 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2528 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2529 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2530 
2531 	{ }
2532 };
2533 
2534 /* Enable GPIO mask and set output */
2535 #define alc880_gpio1_init_verbs	alc_gpio1_init_verbs
2536 #define alc880_gpio2_init_verbs	alc_gpio2_init_verbs
2537 
2538 /* Clevo m520g init */
2539 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2540 	/* headphone output */
2541 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2542 	/* line-out */
2543 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2544 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2545 	/* Line-in */
2546 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2547 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2548 	/* CD */
2549 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2550 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2551 	/* Mic1 (rear panel) */
2552 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2553 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2554 	/* Mic2 (front panel) */
2555 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2556 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2557 	/* headphone */
2558 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2559 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2560         /* change to EAPD mode */
2561 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2562 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2563 
2564 	{ }
2565 };
2566 
2567 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2568 	/* change to EAPD mode */
2569 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2570 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2571 
2572 	/* Headphone output */
2573 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2574 	/* Front output*/
2575 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2576 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2577 
2578 	/* Line In pin widget for input */
2579 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2580 	/* CD pin widget for input */
2581 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2582 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2583 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2584 
2585 	/* change to EAPD mode */
2586 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2587 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2588 
2589 	{ }
2590 };
2591 
2592 /*
2593  * LG m1 express dual
2594  *
2595  * Pin assignment:
2596  *   Rear Line-In/Out (blue): 0x14
2597  *   Build-in Mic-In: 0x15
2598  *   Speaker-out: 0x17
2599  *   HP-Out (green): 0x1b
2600  *   Mic-In/Out (red): 0x19
2601  *   SPDIF-Out: 0x1e
2602  */
2603 
2604 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2605 static hda_nid_t alc880_lg_dac_nids[3] = {
2606 	0x05, 0x02, 0x03
2607 };
2608 
2609 /* seems analog CD is not working */
2610 static struct hda_input_mux alc880_lg_capture_source = {
2611 	.num_items = 3,
2612 	.items = {
2613 		{ "Mic", 0x1 },
2614 		{ "Line", 0x5 },
2615 		{ "Internal Mic", 0x6 },
2616 	},
2617 };
2618 
2619 /* 2,4,6 channel modes */
2620 static struct hda_verb alc880_lg_ch2_init[] = {
2621 	/* set line-in and mic-in to input */
2622 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2623 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2624 	{ }
2625 };
2626 
2627 static struct hda_verb alc880_lg_ch4_init[] = {
2628 	/* set line-in to out and mic-in to input */
2629 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2630 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2631 	{ }
2632 };
2633 
2634 static struct hda_verb alc880_lg_ch6_init[] = {
2635 	/* set line-in and mic-in to output */
2636 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2637 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2638 	{ }
2639 };
2640 
2641 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2642 	{ 2, alc880_lg_ch2_init },
2643 	{ 4, alc880_lg_ch4_init },
2644 	{ 6, alc880_lg_ch6_init },
2645 };
2646 
2647 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2648 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2649 	HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2650 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2651 	HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2652 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2653 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2654 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2655 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2656 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2657 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2658 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2659 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2660 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2661 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2662 	{
2663 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2664 		.name = "Channel Mode",
2665 		.info = alc_ch_mode_info,
2666 		.get = alc_ch_mode_get,
2667 		.put = alc_ch_mode_put,
2668 	},
2669 	{ } /* end */
2670 };
2671 
2672 static struct hda_verb alc880_lg_init_verbs[] = {
2673 	/* set capture source to mic-in */
2674 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2675 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2676 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2677 	/* mute all amp mixer inputs */
2678 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2679 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2680 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2681 	/* line-in to input */
2682 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2683 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2684 	/* built-in mic */
2685 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2686 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2687 	/* speaker-out */
2688 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2689 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2690 	/* mic-in to input */
2691 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2692 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2693 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2694 	/* HP-out */
2695 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2696 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2697 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2698 	/* jack sense */
2699 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2700 	{ }
2701 };
2702 
2703 /* toggle speaker-output according to the hp-jack state */
2704 static void alc880_lg_automute(struct hda_codec *codec)
2705 {
2706 	unsigned int present;
2707 	unsigned char bits;
2708 
2709 	present = snd_hda_codec_read(codec, 0x1b, 0,
2710 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2711 	bits = present ? HDA_AMP_MUTE : 0;
2712 	snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2713 				 HDA_AMP_MUTE, bits);
2714 }
2715 
2716 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2717 {
2718 	/* Looks like the unsol event is incompatible with the standard
2719 	 * definition.  4bit tag is placed at 28 bit!
2720 	 */
2721 	if ((res >> 28) == 0x01)
2722 		alc880_lg_automute(codec);
2723 }
2724 
2725 /*
2726  * LG LW20
2727  *
2728  * Pin assignment:
2729  *   Speaker-out: 0x14
2730  *   Mic-In: 0x18
2731  *   Built-in Mic-In: 0x19
2732  *   Line-In: 0x1b
2733  *   HP-Out: 0x1a
2734  *   SPDIF-Out: 0x1e
2735  */
2736 
2737 static struct hda_input_mux alc880_lg_lw_capture_source = {
2738 	.num_items = 3,
2739 	.items = {
2740 		{ "Mic", 0x0 },
2741 		{ "Internal Mic", 0x1 },
2742 		{ "Line In", 0x2 },
2743 	},
2744 };
2745 
2746 #define alc880_lg_lw_modes alc880_threestack_modes
2747 
2748 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2749 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2750 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2751 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2752 	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2753 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2754 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2755 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2756 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2757 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2758 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2759 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2760 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2761 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2762 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2763 	{
2764 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2765 		.name = "Channel Mode",
2766 		.info = alc_ch_mode_info,
2767 		.get = alc_ch_mode_get,
2768 		.put = alc_ch_mode_put,
2769 	},
2770 	{ } /* end */
2771 };
2772 
2773 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2774 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2775 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2776 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2777 
2778 	/* set capture source to mic-in */
2779 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2780 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2781 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2782 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2783 	/* speaker-out */
2784 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2785 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2786 	/* HP-out */
2787 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2788 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2789 	/* mic-in to input */
2790 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2791 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2792 	/* built-in mic */
2793 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2794 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2795 	/* jack sense */
2796 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2797 	{ }
2798 };
2799 
2800 /* toggle speaker-output according to the hp-jack state */
2801 static void alc880_lg_lw_automute(struct hda_codec *codec)
2802 {
2803 	unsigned int present;
2804 	unsigned char bits;
2805 
2806 	present = snd_hda_codec_read(codec, 0x1b, 0,
2807 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2808 	bits = present ? HDA_AMP_MUTE : 0;
2809 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2810 				 HDA_AMP_MUTE, bits);
2811 }
2812 
2813 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2814 {
2815 	/* Looks like the unsol event is incompatible with the standard
2816 	 * definition.  4bit tag is placed at 28 bit!
2817 	 */
2818 	if ((res >> 28) == 0x01)
2819 		alc880_lg_lw_automute(codec);
2820 }
2821 
2822 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2823 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2824 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2825 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2826 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2827 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2828 	HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2829 	{ } /* end */
2830 };
2831 
2832 static struct hda_input_mux alc880_medion_rim_capture_source = {
2833 	.num_items = 2,
2834 	.items = {
2835 		{ "Mic", 0x0 },
2836 		{ "Internal Mic", 0x1 },
2837 	},
2838 };
2839 
2840 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2841 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2842 
2843 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2844 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2845 
2846 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2847 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2848 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2849 	/* Mic2 (as headphone out) for HP output */
2850 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2851 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2852 	/* Internal Speaker */
2853 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2854 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2855 
2856 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2857 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2858 
2859 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2860 	{ }
2861 };
2862 
2863 /* toggle speaker-output according to the hp-jack state */
2864 static void alc880_medion_rim_automute(struct hda_codec *codec)
2865 {
2866 	unsigned int present;
2867 	unsigned char bits;
2868 
2869 	present = snd_hda_codec_read(codec, 0x14, 0,
2870 				     AC_VERB_GET_PIN_SENSE, 0)
2871 		& AC_PINSENSE_PRESENCE;
2872 	bits = present ? HDA_AMP_MUTE : 0;
2873 	snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2874 				 HDA_AMP_MUTE, bits);
2875 	if (present)
2876 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2877 	else
2878 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2879 }
2880 
2881 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2882 					  unsigned int res)
2883 {
2884 	/* Looks like the unsol event is incompatible with the standard
2885 	 * definition.  4bit tag is placed at 28 bit!
2886 	 */
2887 	if ((res >> 28) == ALC880_HP_EVENT)
2888 		alc880_medion_rim_automute(codec);
2889 }
2890 
2891 #ifdef CONFIG_SND_HDA_POWER_SAVE
2892 static struct hda_amp_list alc880_loopbacks[] = {
2893 	{ 0x0b, HDA_INPUT, 0 },
2894 	{ 0x0b, HDA_INPUT, 1 },
2895 	{ 0x0b, HDA_INPUT, 2 },
2896 	{ 0x0b, HDA_INPUT, 3 },
2897 	{ 0x0b, HDA_INPUT, 4 },
2898 	{ } /* end */
2899 };
2900 
2901 static struct hda_amp_list alc880_lg_loopbacks[] = {
2902 	{ 0x0b, HDA_INPUT, 1 },
2903 	{ 0x0b, HDA_INPUT, 6 },
2904 	{ 0x0b, HDA_INPUT, 7 },
2905 	{ } /* end */
2906 };
2907 #endif
2908 
2909 /*
2910  * Common callbacks
2911  */
2912 
2913 static int alc_init(struct hda_codec *codec)
2914 {
2915 	struct alc_spec *spec = codec->spec;
2916 	unsigned int i;
2917 
2918 	alc_fix_pll(codec);
2919 	if (codec->vendor_id == 0x10ec0888)
2920 		alc888_coef_init(codec);
2921 
2922 	for (i = 0; i < spec->num_init_verbs; i++)
2923 		snd_hda_sequence_write(codec, spec->init_verbs[i]);
2924 
2925 	if (spec->init_hook)
2926 		spec->init_hook(codec);
2927 
2928 	return 0;
2929 }
2930 
2931 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2932 {
2933 	struct alc_spec *spec = codec->spec;
2934 
2935 	if (spec->unsol_event)
2936 		spec->unsol_event(codec, res);
2937 }
2938 
2939 #ifdef CONFIG_SND_HDA_POWER_SAVE
2940 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2941 {
2942 	struct alc_spec *spec = codec->spec;
2943 	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2944 }
2945 #endif
2946 
2947 /*
2948  * Analog playback callbacks
2949  */
2950 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2951 				    struct hda_codec *codec,
2952 				    struct snd_pcm_substream *substream)
2953 {
2954 	struct alc_spec *spec = codec->spec;
2955 	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2956 					     hinfo);
2957 }
2958 
2959 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2960 				       struct hda_codec *codec,
2961 				       unsigned int stream_tag,
2962 				       unsigned int format,
2963 				       struct snd_pcm_substream *substream)
2964 {
2965 	struct alc_spec *spec = codec->spec;
2966 	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2967 						stream_tag, format, substream);
2968 }
2969 
2970 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2971 				       struct hda_codec *codec,
2972 				       struct snd_pcm_substream *substream)
2973 {
2974 	struct alc_spec *spec = codec->spec;
2975 	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2976 }
2977 
2978 /*
2979  * Digital out
2980  */
2981 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2982 					struct hda_codec *codec,
2983 					struct snd_pcm_substream *substream)
2984 {
2985 	struct alc_spec *spec = codec->spec;
2986 	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2987 }
2988 
2989 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2990 					   struct hda_codec *codec,
2991 					   unsigned int stream_tag,
2992 					   unsigned int format,
2993 					   struct snd_pcm_substream *substream)
2994 {
2995 	struct alc_spec *spec = codec->spec;
2996 	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2997 					     stream_tag, format, substream);
2998 }
2999 
3000 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3001 					   struct hda_codec *codec,
3002 					   struct snd_pcm_substream *substream)
3003 {
3004 	struct alc_spec *spec = codec->spec;
3005 	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3006 }
3007 
3008 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3009 					 struct hda_codec *codec,
3010 					 struct snd_pcm_substream *substream)
3011 {
3012 	struct alc_spec *spec = codec->spec;
3013 	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3014 }
3015 
3016 /*
3017  * Analog capture
3018  */
3019 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3020 				      struct hda_codec *codec,
3021 				      unsigned int stream_tag,
3022 				      unsigned int format,
3023 				      struct snd_pcm_substream *substream)
3024 {
3025 	struct alc_spec *spec = codec->spec;
3026 
3027 	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3028 				   stream_tag, 0, format);
3029 	return 0;
3030 }
3031 
3032 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3033 				      struct hda_codec *codec,
3034 				      struct snd_pcm_substream *substream)
3035 {
3036 	struct alc_spec *spec = codec->spec;
3037 
3038 	snd_hda_codec_cleanup_stream(codec,
3039 				     spec->adc_nids[substream->number + 1]);
3040 	return 0;
3041 }
3042 
3043 
3044 /*
3045  */
3046 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3047 	.substreams = 1,
3048 	.channels_min = 2,
3049 	.channels_max = 8,
3050 	/* NID is set in alc_build_pcms */
3051 	.ops = {
3052 		.open = alc880_playback_pcm_open,
3053 		.prepare = alc880_playback_pcm_prepare,
3054 		.cleanup = alc880_playback_pcm_cleanup
3055 	},
3056 };
3057 
3058 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3059 	.substreams = 1,
3060 	.channels_min = 2,
3061 	.channels_max = 2,
3062 	/* NID is set in alc_build_pcms */
3063 };
3064 
3065 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3066 	.substreams = 1,
3067 	.channels_min = 2,
3068 	.channels_max = 2,
3069 	/* NID is set in alc_build_pcms */
3070 };
3071 
3072 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3073 	.substreams = 2, /* can be overridden */
3074 	.channels_min = 2,
3075 	.channels_max = 2,
3076 	/* NID is set in alc_build_pcms */
3077 	.ops = {
3078 		.prepare = alc880_alt_capture_pcm_prepare,
3079 		.cleanup = alc880_alt_capture_pcm_cleanup
3080 	},
3081 };
3082 
3083 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3084 	.substreams = 1,
3085 	.channels_min = 2,
3086 	.channels_max = 2,
3087 	/* NID is set in alc_build_pcms */
3088 	.ops = {
3089 		.open = alc880_dig_playback_pcm_open,
3090 		.close = alc880_dig_playback_pcm_close,
3091 		.prepare = alc880_dig_playback_pcm_prepare,
3092 		.cleanup = alc880_dig_playback_pcm_cleanup
3093 	},
3094 };
3095 
3096 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3097 	.substreams = 1,
3098 	.channels_min = 2,
3099 	.channels_max = 2,
3100 	/* NID is set in alc_build_pcms */
3101 };
3102 
3103 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3104 static struct hda_pcm_stream alc_pcm_null_stream = {
3105 	.substreams = 0,
3106 	.channels_min = 0,
3107 	.channels_max = 0,
3108 };
3109 
3110 static int alc_build_pcms(struct hda_codec *codec)
3111 {
3112 	struct alc_spec *spec = codec->spec;
3113 	struct hda_pcm *info = spec->pcm_rec;
3114 	int i;
3115 
3116 	codec->num_pcms = 1;
3117 	codec->pcm_info = info;
3118 
3119 	if (spec->no_analog)
3120 		goto skip_analog;
3121 
3122 	info->name = spec->stream_name_analog;
3123 	if (spec->stream_analog_playback) {
3124 		if (snd_BUG_ON(!spec->multiout.dac_nids))
3125 			return -EINVAL;
3126 		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3127 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3128 	}
3129 	if (spec->stream_analog_capture) {
3130 		if (snd_BUG_ON(!spec->adc_nids))
3131 			return -EINVAL;
3132 		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3133 		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3134 	}
3135 
3136 	if (spec->channel_mode) {
3137 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3138 		for (i = 0; i < spec->num_channel_mode; i++) {
3139 			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3140 				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3141 			}
3142 		}
3143 	}
3144 
3145  skip_analog:
3146 	/* SPDIF for stream index #1 */
3147 	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3148 		codec->num_pcms = 2;
3149 	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3150 		info = spec->pcm_rec + 1;
3151 		info->name = spec->stream_name_digital;
3152 		if (spec->dig_out_type)
3153 			info->pcm_type = spec->dig_out_type;
3154 		else
3155 			info->pcm_type = HDA_PCM_TYPE_SPDIF;
3156 		if (spec->multiout.dig_out_nid &&
3157 		    spec->stream_digital_playback) {
3158 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3159 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3160 		}
3161 		if (spec->dig_in_nid &&
3162 		    spec->stream_digital_capture) {
3163 			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3164 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3165 		}
3166 		/* FIXME: do we need this for all Realtek codec models? */
3167 		codec->spdif_status_reset = 1;
3168 	}
3169 
3170 	if (spec->no_analog)
3171 		return 0;
3172 
3173 	/* If the use of more than one ADC is requested for the current
3174 	 * model, configure a second analog capture-only PCM.
3175 	 */
3176 	/* Additional Analaog capture for index #2 */
3177 	if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3178 	    (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3179 		codec->num_pcms = 3;
3180 		info = spec->pcm_rec + 2;
3181 		info->name = spec->stream_name_analog;
3182 		if (spec->alt_dac_nid) {
3183 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3184 				*spec->stream_analog_alt_playback;
3185 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3186 				spec->alt_dac_nid;
3187 		} else {
3188 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3189 				alc_pcm_null_stream;
3190 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3191 		}
3192 		if (spec->num_adc_nids > 1) {
3193 			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3194 				*spec->stream_analog_alt_capture;
3195 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3196 				spec->adc_nids[1];
3197 			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3198 				spec->num_adc_nids - 1;
3199 		} else {
3200 			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3201 				alc_pcm_null_stream;
3202 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3203 		}
3204 	}
3205 
3206 	return 0;
3207 }
3208 
3209 static void alc_free_kctls(struct hda_codec *codec)
3210 {
3211 	struct alc_spec *spec = codec->spec;
3212 
3213 	if (spec->kctls.list) {
3214 		struct snd_kcontrol_new *kctl = spec->kctls.list;
3215 		int i;
3216 		for (i = 0; i < spec->kctls.used; i++)
3217 			kfree(kctl[i].name);
3218 	}
3219 	snd_array_free(&spec->kctls);
3220 }
3221 
3222 static void alc_free(struct hda_codec *codec)
3223 {
3224 	struct alc_spec *spec = codec->spec;
3225 
3226 	if (!spec)
3227 		return;
3228 
3229 	alc_free_kctls(codec);
3230 	kfree(spec);
3231 	snd_hda_detach_beep_device(codec);
3232 }
3233 
3234 #ifdef SND_HDA_NEEDS_RESUME
3235 static int alc_resume(struct hda_codec *codec)
3236 {
3237 	codec->patch_ops.init(codec);
3238 	snd_hda_codec_resume_amp(codec);
3239 	snd_hda_codec_resume_cache(codec);
3240 	return 0;
3241 }
3242 #endif
3243 
3244 /*
3245  */
3246 static struct hda_codec_ops alc_patch_ops = {
3247 	.build_controls = alc_build_controls,
3248 	.build_pcms = alc_build_pcms,
3249 	.init = alc_init,
3250 	.free = alc_free,
3251 	.unsol_event = alc_unsol_event,
3252 #ifdef SND_HDA_NEEDS_RESUME
3253 	.resume = alc_resume,
3254 #endif
3255 #ifdef CONFIG_SND_HDA_POWER_SAVE
3256 	.check_power_status = alc_check_power_status,
3257 #endif
3258 };
3259 
3260 
3261 /*
3262  * Test configuration for debugging
3263  *
3264  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3265  * enum controls.
3266  */
3267 #ifdef CONFIG_SND_DEBUG
3268 static hda_nid_t alc880_test_dac_nids[4] = {
3269 	0x02, 0x03, 0x04, 0x05
3270 };
3271 
3272 static struct hda_input_mux alc880_test_capture_source = {
3273 	.num_items = 7,
3274 	.items = {
3275 		{ "In-1", 0x0 },
3276 		{ "In-2", 0x1 },
3277 		{ "In-3", 0x2 },
3278 		{ "In-4", 0x3 },
3279 		{ "CD", 0x4 },
3280 		{ "Front", 0x5 },
3281 		{ "Surround", 0x6 },
3282 	},
3283 };
3284 
3285 static struct hda_channel_mode alc880_test_modes[4] = {
3286 	{ 2, NULL },
3287 	{ 4, NULL },
3288 	{ 6, NULL },
3289 	{ 8, NULL },
3290 };
3291 
3292 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3293 				 struct snd_ctl_elem_info *uinfo)
3294 {
3295 	static char *texts[] = {
3296 		"N/A", "Line Out", "HP Out",
3297 		"In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3298 	};
3299 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3300 	uinfo->count = 1;
3301 	uinfo->value.enumerated.items = 8;
3302 	if (uinfo->value.enumerated.item >= 8)
3303 		uinfo->value.enumerated.item = 7;
3304 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3305 	return 0;
3306 }
3307 
3308 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3309 				struct snd_ctl_elem_value *ucontrol)
3310 {
3311 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3312 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3313 	unsigned int pin_ctl, item = 0;
3314 
3315 	pin_ctl = snd_hda_codec_read(codec, nid, 0,
3316 				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3317 	if (pin_ctl & AC_PINCTL_OUT_EN) {
3318 		if (pin_ctl & AC_PINCTL_HP_EN)
3319 			item = 2;
3320 		else
3321 			item = 1;
3322 	} else if (pin_ctl & AC_PINCTL_IN_EN) {
3323 		switch (pin_ctl & AC_PINCTL_VREFEN) {
3324 		case AC_PINCTL_VREF_HIZ: item = 3; break;
3325 		case AC_PINCTL_VREF_50:  item = 4; break;
3326 		case AC_PINCTL_VREF_GRD: item = 5; break;
3327 		case AC_PINCTL_VREF_80:  item = 6; break;
3328 		case AC_PINCTL_VREF_100: item = 7; break;
3329 		}
3330 	}
3331 	ucontrol->value.enumerated.item[0] = item;
3332 	return 0;
3333 }
3334 
3335 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3336 				struct snd_ctl_elem_value *ucontrol)
3337 {
3338 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3339 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3340 	static unsigned int ctls[] = {
3341 		0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3342 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3343 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3344 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3345 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3346 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3347 	};
3348 	unsigned int old_ctl, new_ctl;
3349 
3350 	old_ctl = snd_hda_codec_read(codec, nid, 0,
3351 				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3352 	new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3353 	if (old_ctl != new_ctl) {
3354 		int val;
3355 		snd_hda_codec_write_cache(codec, nid, 0,
3356 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
3357 					  new_ctl);
3358 		val = ucontrol->value.enumerated.item[0] >= 3 ?
3359 			HDA_AMP_MUTE : 0;
3360 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3361 					 HDA_AMP_MUTE, val);
3362 		return 1;
3363 	}
3364 	return 0;
3365 }
3366 
3367 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3368 				 struct snd_ctl_elem_info *uinfo)
3369 {
3370 	static char *texts[] = {
3371 		"Front", "Surround", "CLFE", "Side"
3372 	};
3373 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3374 	uinfo->count = 1;
3375 	uinfo->value.enumerated.items = 4;
3376 	if (uinfo->value.enumerated.item >= 4)
3377 		uinfo->value.enumerated.item = 3;
3378 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3379 	return 0;
3380 }
3381 
3382 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3383 				struct snd_ctl_elem_value *ucontrol)
3384 {
3385 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3386 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3387 	unsigned int sel;
3388 
3389 	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3390 	ucontrol->value.enumerated.item[0] = sel & 3;
3391 	return 0;
3392 }
3393 
3394 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3395 				struct snd_ctl_elem_value *ucontrol)
3396 {
3397 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3398 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3399 	unsigned int sel;
3400 
3401 	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3402 	if (ucontrol->value.enumerated.item[0] != sel) {
3403 		sel = ucontrol->value.enumerated.item[0] & 3;
3404 		snd_hda_codec_write_cache(codec, nid, 0,
3405 					  AC_VERB_SET_CONNECT_SEL, sel);
3406 		return 1;
3407 	}
3408 	return 0;
3409 }
3410 
3411 #define PIN_CTL_TEST(xname,nid) {			\
3412 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
3413 			.name = xname,		       \
3414 			.info = alc_test_pin_ctl_info, \
3415 			.get = alc_test_pin_ctl_get,   \
3416 			.put = alc_test_pin_ctl_put,   \
3417 			.private_value = nid	       \
3418 			}
3419 
3420 #define PIN_SRC_TEST(xname,nid) {			\
3421 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
3422 			.name = xname,		       \
3423 			.info = alc_test_pin_src_info, \
3424 			.get = alc_test_pin_src_get,   \
3425 			.put = alc_test_pin_src_put,   \
3426 			.private_value = nid	       \
3427 			}
3428 
3429 static struct snd_kcontrol_new alc880_test_mixer[] = {
3430 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3431 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3432 	HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3433 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3434 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3435 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3436 	HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3437 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3438 	PIN_CTL_TEST("Front Pin Mode", 0x14),
3439 	PIN_CTL_TEST("Surround Pin Mode", 0x15),
3440 	PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3441 	PIN_CTL_TEST("Side Pin Mode", 0x17),
3442 	PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3443 	PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3444 	PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3445 	PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3446 	PIN_SRC_TEST("In-1 Pin Source", 0x18),
3447 	PIN_SRC_TEST("In-2 Pin Source", 0x19),
3448 	PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3449 	PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3450 	HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3451 	HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3452 	HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3453 	HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3454 	HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3455 	HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3456 	HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3457 	HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3458 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3459 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3460 	{
3461 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3462 		.name = "Channel Mode",
3463 		.info = alc_ch_mode_info,
3464 		.get = alc_ch_mode_get,
3465 		.put = alc_ch_mode_put,
3466 	},
3467 	{ } /* end */
3468 };
3469 
3470 static struct hda_verb alc880_test_init_verbs[] = {
3471 	/* Unmute inputs of 0x0c - 0x0f */
3472 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3473 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3474 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3475 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3476 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3477 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3478 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3479 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3480 	/* Vol output for 0x0c-0x0f */
3481 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3482 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3483 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3484 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3485 	/* Set output pins 0x14-0x17 */
3486 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3487 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3488 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3489 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3490 	/* Unmute output pins 0x14-0x17 */
3491 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3492 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3493 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3494 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3495 	/* Set input pins 0x18-0x1c */
3496 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3497 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3498 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3499 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3500 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3501 	/* Mute input pins 0x18-0x1b */
3502 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3503 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3504 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3505 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3506 	/* ADC set up */
3507 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3508 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3509 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3510 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3511 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3512 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3513 	/* Analog input/passthru */
3514 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3515 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3516 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3517 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3518 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3519 	{ }
3520 };
3521 #endif
3522 
3523 /*
3524  */
3525 
3526 static const char *alc880_models[ALC880_MODEL_LAST] = {
3527 	[ALC880_3ST]		= "3stack",
3528 	[ALC880_TCL_S700]	= "tcl",
3529 	[ALC880_3ST_DIG]	= "3stack-digout",
3530 	[ALC880_CLEVO]		= "clevo",
3531 	[ALC880_5ST]		= "5stack",
3532 	[ALC880_5ST_DIG]	= "5stack-digout",
3533 	[ALC880_W810]		= "w810",
3534 	[ALC880_Z71V]		= "z71v",
3535 	[ALC880_6ST]		= "6stack",
3536 	[ALC880_6ST_DIG]	= "6stack-digout",
3537 	[ALC880_ASUS]		= "asus",
3538 	[ALC880_ASUS_W1V]	= "asus-w1v",
3539 	[ALC880_ASUS_DIG]	= "asus-dig",
3540 	[ALC880_ASUS_DIG2]	= "asus-dig2",
3541 	[ALC880_UNIWILL_DIG]	= "uniwill",
3542 	[ALC880_UNIWILL_P53]	= "uniwill-p53",
3543 	[ALC880_FUJITSU]	= "fujitsu",
3544 	[ALC880_F1734]		= "F1734",
3545 	[ALC880_LG]		= "lg",
3546 	[ALC880_LG_LW]		= "lg-lw",
3547 	[ALC880_MEDION_RIM]	= "medion",
3548 #ifdef CONFIG_SND_DEBUG
3549 	[ALC880_TEST]		= "test",
3550 #endif
3551 	[ALC880_AUTO]		= "auto",
3552 };
3553 
3554 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3555 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3556 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3557 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3558 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3559 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3560 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3561 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3562 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3563 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3564 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3565 	SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3566 	SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3567 	SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3568 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3569 	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3570 	SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3571 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3572 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3573 	/* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3574 	SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3575 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3576 	SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3577 	SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3578 	SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3579 	SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3580 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3581 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3582 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3583 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3584 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3585 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3586 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3587 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3588 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3589 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3590 	SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3591 	SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3592 	SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3593 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3594 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3595 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3596 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3597 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3598 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3599 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3600 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3601 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3602 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3603 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3604 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3605 	SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3606 	SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3607 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3608 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3609 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3610 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3611 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3612 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3613 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3614 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3615 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3616 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3617 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3618 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3619 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3620 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3621 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3622 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3623 	/* default Intel */
3624 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3625 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3626 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3627 	{}
3628 };
3629 
3630 /*
3631  * ALC880 codec presets
3632  */
3633 static struct alc_config_preset alc880_presets[] = {
3634 	[ALC880_3ST] = {
3635 		.mixers = { alc880_three_stack_mixer },
3636 		.init_verbs = { alc880_volume_init_verbs,
3637 				alc880_pin_3stack_init_verbs },
3638 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3639 		.dac_nids = alc880_dac_nids,
3640 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3641 		.channel_mode = alc880_threestack_modes,
3642 		.need_dac_fix = 1,
3643 		.input_mux = &alc880_capture_source,
3644 	},
3645 	[ALC880_3ST_DIG] = {
3646 		.mixers = { alc880_three_stack_mixer },
3647 		.init_verbs = { alc880_volume_init_verbs,
3648 				alc880_pin_3stack_init_verbs },
3649 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3650 		.dac_nids = alc880_dac_nids,
3651 		.dig_out_nid = ALC880_DIGOUT_NID,
3652 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3653 		.channel_mode = alc880_threestack_modes,
3654 		.need_dac_fix = 1,
3655 		.input_mux = &alc880_capture_source,
3656 	},
3657 	[ALC880_TCL_S700] = {
3658 		.mixers = { alc880_tcl_s700_mixer },
3659 		.init_verbs = { alc880_volume_init_verbs,
3660 				alc880_pin_tcl_S700_init_verbs,
3661 				alc880_gpio2_init_verbs },
3662 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3663 		.dac_nids = alc880_dac_nids,
3664 		.adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3665 		.num_adc_nids = 1, /* single ADC */
3666 		.hp_nid = 0x03,
3667 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3668 		.channel_mode = alc880_2_jack_modes,
3669 		.input_mux = &alc880_capture_source,
3670 	},
3671 	[ALC880_5ST] = {
3672 		.mixers = { alc880_three_stack_mixer,
3673 			    alc880_five_stack_mixer},
3674 		.init_verbs = { alc880_volume_init_verbs,
3675 				alc880_pin_5stack_init_verbs },
3676 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3677 		.dac_nids = alc880_dac_nids,
3678 		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3679 		.channel_mode = alc880_fivestack_modes,
3680 		.input_mux = &alc880_capture_source,
3681 	},
3682 	[ALC880_5ST_DIG] = {
3683 		.mixers = { alc880_three_stack_mixer,
3684 			    alc880_five_stack_mixer },
3685 		.init_verbs = { alc880_volume_init_verbs,
3686 				alc880_pin_5stack_init_verbs },
3687 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3688 		.dac_nids = alc880_dac_nids,
3689 		.dig_out_nid = ALC880_DIGOUT_NID,
3690 		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3691 		.channel_mode = alc880_fivestack_modes,
3692 		.input_mux = &alc880_capture_source,
3693 	},
3694 	[ALC880_6ST] = {
3695 		.mixers = { alc880_six_stack_mixer },
3696 		.init_verbs = { alc880_volume_init_verbs,
3697 				alc880_pin_6stack_init_verbs },
3698 		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3699 		.dac_nids = alc880_6st_dac_nids,
3700 		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3701 		.channel_mode = alc880_sixstack_modes,
3702 		.input_mux = &alc880_6stack_capture_source,
3703 	},
3704 	[ALC880_6ST_DIG] = {
3705 		.mixers = { alc880_six_stack_mixer },
3706 		.init_verbs = { alc880_volume_init_verbs,
3707 				alc880_pin_6stack_init_verbs },
3708 		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3709 		.dac_nids = alc880_6st_dac_nids,
3710 		.dig_out_nid = ALC880_DIGOUT_NID,
3711 		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3712 		.channel_mode = alc880_sixstack_modes,
3713 		.input_mux = &alc880_6stack_capture_source,
3714 	},
3715 	[ALC880_W810] = {
3716 		.mixers = { alc880_w810_base_mixer },
3717 		.init_verbs = { alc880_volume_init_verbs,
3718 				alc880_pin_w810_init_verbs,
3719 				alc880_gpio2_init_verbs },
3720 		.num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3721 		.dac_nids = alc880_w810_dac_nids,
3722 		.dig_out_nid = ALC880_DIGOUT_NID,
3723 		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3724 		.channel_mode = alc880_w810_modes,
3725 		.input_mux = &alc880_capture_source,
3726 	},
3727 	[ALC880_Z71V] = {
3728 		.mixers = { alc880_z71v_mixer },
3729 		.init_verbs = { alc880_volume_init_verbs,
3730 				alc880_pin_z71v_init_verbs },
3731 		.num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3732 		.dac_nids = alc880_z71v_dac_nids,
3733 		.dig_out_nid = ALC880_DIGOUT_NID,
3734 		.hp_nid = 0x03,
3735 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3736 		.channel_mode = alc880_2_jack_modes,
3737 		.input_mux = &alc880_capture_source,
3738 	},
3739 	[ALC880_F1734] = {
3740 		.mixers = { alc880_f1734_mixer },
3741 		.init_verbs = { alc880_volume_init_verbs,
3742 				alc880_pin_f1734_init_verbs },
3743 		.num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3744 		.dac_nids = alc880_f1734_dac_nids,
3745 		.hp_nid = 0x02,
3746 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3747 		.channel_mode = alc880_2_jack_modes,
3748 		.input_mux = &alc880_f1734_capture_source,
3749 		.unsol_event = alc880_uniwill_p53_unsol_event,
3750 		.init_hook = alc880_uniwill_p53_hp_automute,
3751 	},
3752 	[ALC880_ASUS] = {
3753 		.mixers = { alc880_asus_mixer },
3754 		.init_verbs = { alc880_volume_init_verbs,
3755 				alc880_pin_asus_init_verbs,
3756 				alc880_gpio1_init_verbs },
3757 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3758 		.dac_nids = alc880_asus_dac_nids,
3759 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3760 		.channel_mode = alc880_asus_modes,
3761 		.need_dac_fix = 1,
3762 		.input_mux = &alc880_capture_source,
3763 	},
3764 	[ALC880_ASUS_DIG] = {
3765 		.mixers = { alc880_asus_mixer },
3766 		.init_verbs = { alc880_volume_init_verbs,
3767 				alc880_pin_asus_init_verbs,
3768 				alc880_gpio1_init_verbs },
3769 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3770 		.dac_nids = alc880_asus_dac_nids,
3771 		.dig_out_nid = ALC880_DIGOUT_NID,
3772 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3773 		.channel_mode = alc880_asus_modes,
3774 		.need_dac_fix = 1,
3775 		.input_mux = &alc880_capture_source,
3776 	},
3777 	[ALC880_ASUS_DIG2] = {
3778 		.mixers = { alc880_asus_mixer },
3779 		.init_verbs = { alc880_volume_init_verbs,
3780 				alc880_pin_asus_init_verbs,
3781 				alc880_gpio2_init_verbs }, /* use GPIO2 */
3782 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3783 		.dac_nids = alc880_asus_dac_nids,
3784 		.dig_out_nid = ALC880_DIGOUT_NID,
3785 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3786 		.channel_mode = alc880_asus_modes,
3787 		.need_dac_fix = 1,
3788 		.input_mux = &alc880_capture_source,
3789 	},
3790 	[ALC880_ASUS_W1V] = {
3791 		.mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3792 		.init_verbs = { alc880_volume_init_verbs,
3793 				alc880_pin_asus_init_verbs,
3794 				alc880_gpio1_init_verbs },
3795 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3796 		.dac_nids = alc880_asus_dac_nids,
3797 		.dig_out_nid = ALC880_DIGOUT_NID,
3798 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3799 		.channel_mode = alc880_asus_modes,
3800 		.need_dac_fix = 1,
3801 		.input_mux = &alc880_capture_source,
3802 	},
3803 	[ALC880_UNIWILL_DIG] = {
3804 		.mixers = { alc880_asus_mixer },
3805 		.init_verbs = { alc880_volume_init_verbs,
3806 				alc880_pin_asus_init_verbs },
3807 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3808 		.dac_nids = alc880_asus_dac_nids,
3809 		.dig_out_nid = ALC880_DIGOUT_NID,
3810 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3811 		.channel_mode = alc880_asus_modes,
3812 		.need_dac_fix = 1,
3813 		.input_mux = &alc880_capture_source,
3814 	},
3815 	[ALC880_UNIWILL] = {
3816 		.mixers = { alc880_uniwill_mixer },
3817 		.init_verbs = { alc880_volume_init_verbs,
3818 				alc880_uniwill_init_verbs },
3819 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3820 		.dac_nids = alc880_asus_dac_nids,
3821 		.dig_out_nid = ALC880_DIGOUT_NID,
3822 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3823 		.channel_mode = alc880_threestack_modes,
3824 		.need_dac_fix = 1,
3825 		.input_mux = &alc880_capture_source,
3826 		.unsol_event = alc880_uniwill_unsol_event,
3827 		.init_hook = alc880_uniwill_automute,
3828 	},
3829 	[ALC880_UNIWILL_P53] = {
3830 		.mixers = { alc880_uniwill_p53_mixer },
3831 		.init_verbs = { alc880_volume_init_verbs,
3832 				alc880_uniwill_p53_init_verbs },
3833 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3834 		.dac_nids = alc880_asus_dac_nids,
3835 		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3836 		.channel_mode = alc880_threestack_modes,
3837 		.input_mux = &alc880_capture_source,
3838 		.unsol_event = alc880_uniwill_p53_unsol_event,
3839 		.init_hook = alc880_uniwill_p53_hp_automute,
3840 	},
3841 	[ALC880_FUJITSU] = {
3842 		.mixers = { alc880_fujitsu_mixer },
3843 		.init_verbs = { alc880_volume_init_verbs,
3844 				alc880_uniwill_p53_init_verbs,
3845 	       			alc880_beep_init_verbs },
3846 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3847 		.dac_nids = alc880_dac_nids,
3848 		.dig_out_nid = ALC880_DIGOUT_NID,
3849 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3850 		.channel_mode = alc880_2_jack_modes,
3851 		.input_mux = &alc880_capture_source,
3852 		.unsol_event = alc880_uniwill_p53_unsol_event,
3853 		.init_hook = alc880_uniwill_p53_hp_automute,
3854 	},
3855 	[ALC880_CLEVO] = {
3856 		.mixers = { alc880_three_stack_mixer },
3857 		.init_verbs = { alc880_volume_init_verbs,
3858 				alc880_pin_clevo_init_verbs },
3859 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3860 		.dac_nids = alc880_dac_nids,
3861 		.hp_nid = 0x03,
3862 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3863 		.channel_mode = alc880_threestack_modes,
3864 		.need_dac_fix = 1,
3865 		.input_mux = &alc880_capture_source,
3866 	},
3867 	[ALC880_LG] = {
3868 		.mixers = { alc880_lg_mixer },
3869 		.init_verbs = { alc880_volume_init_verbs,
3870 				alc880_lg_init_verbs },
3871 		.num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3872 		.dac_nids = alc880_lg_dac_nids,
3873 		.dig_out_nid = ALC880_DIGOUT_NID,
3874 		.num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3875 		.channel_mode = alc880_lg_ch_modes,
3876 		.need_dac_fix = 1,
3877 		.input_mux = &alc880_lg_capture_source,
3878 		.unsol_event = alc880_lg_unsol_event,
3879 		.init_hook = alc880_lg_automute,
3880 #ifdef CONFIG_SND_HDA_POWER_SAVE
3881 		.loopbacks = alc880_lg_loopbacks,
3882 #endif
3883 	},
3884 	[ALC880_LG_LW] = {
3885 		.mixers = { alc880_lg_lw_mixer },
3886 		.init_verbs = { alc880_volume_init_verbs,
3887 				alc880_lg_lw_init_verbs },
3888 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3889 		.dac_nids = alc880_dac_nids,
3890 		.dig_out_nid = ALC880_DIGOUT_NID,
3891 		.num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3892 		.channel_mode = alc880_lg_lw_modes,
3893 		.input_mux = &alc880_lg_lw_capture_source,
3894 		.unsol_event = alc880_lg_lw_unsol_event,
3895 		.init_hook = alc880_lg_lw_automute,
3896 	},
3897 	[ALC880_MEDION_RIM] = {
3898 		.mixers = { alc880_medion_rim_mixer },
3899 		.init_verbs = { alc880_volume_init_verbs,
3900 				alc880_medion_rim_init_verbs,
3901 				alc_gpio2_init_verbs },
3902 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
3903 		.dac_nids = alc880_dac_nids,
3904 		.dig_out_nid = ALC880_DIGOUT_NID,
3905 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3906 		.channel_mode = alc880_2_jack_modes,
3907 		.input_mux = &alc880_medion_rim_capture_source,
3908 		.unsol_event = alc880_medion_rim_unsol_event,
3909 		.init_hook = alc880_medion_rim_automute,
3910 	},
3911 #ifdef CONFIG_SND_DEBUG
3912 	[ALC880_TEST] = {
3913 		.mixers = { alc880_test_mixer },
3914 		.init_verbs = { alc880_test_init_verbs },
3915 		.num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3916 		.dac_nids = alc880_test_dac_nids,
3917 		.dig_out_nid = ALC880_DIGOUT_NID,
3918 		.num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3919 		.channel_mode = alc880_test_modes,
3920 		.input_mux = &alc880_test_capture_source,
3921 	},
3922 #endif
3923 };
3924 
3925 /*
3926  * Automatic parse of I/O pins from the BIOS configuration
3927  */
3928 
3929 enum {
3930 	ALC_CTL_WIDGET_VOL,
3931 	ALC_CTL_WIDGET_MUTE,
3932 	ALC_CTL_BIND_MUTE,
3933 };
3934 static struct snd_kcontrol_new alc880_control_templates[] = {
3935 	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3936 	HDA_CODEC_MUTE(NULL, 0, 0, 0),
3937 	HDA_BIND_MUTE(NULL, 0, 0, 0),
3938 };
3939 
3940 /* add dynamic controls */
3941 static int add_control(struct alc_spec *spec, int type, const char *name,
3942 		       unsigned long val)
3943 {
3944 	struct snd_kcontrol_new *knew;
3945 
3946 	snd_array_init(&spec->kctls, sizeof(*knew), 32);
3947 	knew = snd_array_new(&spec->kctls);
3948 	if (!knew)
3949 		return -ENOMEM;
3950 	*knew = alc880_control_templates[type];
3951 	knew->name = kstrdup(name, GFP_KERNEL);
3952 	if (!knew->name)
3953 		return -ENOMEM;
3954 	knew->private_value = val;
3955 	return 0;
3956 }
3957 
3958 #define alc880_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
3959 #define alc880_fixed_pin_idx(nid)	((nid) - 0x14)
3960 #define alc880_is_multi_pin(nid)	((nid) >= 0x18)
3961 #define alc880_multi_pin_idx(nid)	((nid) - 0x18)
3962 #define alc880_is_input_pin(nid)	((nid) >= 0x18)
3963 #define alc880_input_pin_idx(nid)	((nid) - 0x18)
3964 #define alc880_idx_to_dac(nid)		((nid) + 0x02)
3965 #define alc880_dac_to_idx(nid)		((nid) - 0x02)
3966 #define alc880_idx_to_mixer(nid)	((nid) + 0x0c)
3967 #define alc880_idx_to_selector(nid)	((nid) + 0x10)
3968 #define ALC880_PIN_CD_NID		0x1c
3969 
3970 /* fill in the dac_nids table from the parsed pin configuration */
3971 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3972 				     const struct auto_pin_cfg *cfg)
3973 {
3974 	hda_nid_t nid;
3975 	int assigned[4];
3976 	int i, j;
3977 
3978 	memset(assigned, 0, sizeof(assigned));
3979 	spec->multiout.dac_nids = spec->private_dac_nids;
3980 
3981 	/* check the pins hardwired to audio widget */
3982 	for (i = 0; i < cfg->line_outs; i++) {
3983 		nid = cfg->line_out_pins[i];
3984 		if (alc880_is_fixed_pin(nid)) {
3985 			int idx = alc880_fixed_pin_idx(nid);
3986 			spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3987 			assigned[idx] = 1;
3988 		}
3989 	}
3990 	/* left pins can be connect to any audio widget */
3991 	for (i = 0; i < cfg->line_outs; i++) {
3992 		nid = cfg->line_out_pins[i];
3993 		if (alc880_is_fixed_pin(nid))
3994 			continue;
3995 		/* search for an empty channel */
3996 		for (j = 0; j < cfg->line_outs; j++) {
3997 			if (!assigned[j]) {
3998 				spec->multiout.dac_nids[i] =
3999 					alc880_idx_to_dac(j);
4000 				assigned[j] = 1;
4001 				break;
4002 			}
4003 		}
4004 	}
4005 	spec->multiout.num_dacs = cfg->line_outs;
4006 	return 0;
4007 }
4008 
4009 /* add playback controls from the parsed DAC table */
4010 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4011 					     const struct auto_pin_cfg *cfg)
4012 {
4013 	char name[32];
4014 	static const char *chname[4] = {
4015 		"Front", "Surround", NULL /*CLFE*/, "Side"
4016 	};
4017 	hda_nid_t nid;
4018 	int i, err;
4019 
4020 	for (i = 0; i < cfg->line_outs; i++) {
4021 		if (!spec->multiout.dac_nids[i])
4022 			continue;
4023 		nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4024 		if (i == 2) {
4025 			/* Center/LFE */
4026 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
4027 					  "Center Playback Volume",
4028 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4029 							      HDA_OUTPUT));
4030 			if (err < 0)
4031 				return err;
4032 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
4033 					  "LFE Playback Volume",
4034 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4035 							      HDA_OUTPUT));
4036 			if (err < 0)
4037 				return err;
4038 			err = add_control(spec, ALC_CTL_BIND_MUTE,
4039 					  "Center Playback Switch",
4040 					  HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4041 							      HDA_INPUT));
4042 			if (err < 0)
4043 				return err;
4044 			err = add_control(spec, ALC_CTL_BIND_MUTE,
4045 					  "LFE Playback Switch",
4046 					  HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4047 							      HDA_INPUT));
4048 			if (err < 0)
4049 				return err;
4050 		} else {
4051 			sprintf(name, "%s Playback Volume", chname[i]);
4052 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4053 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4054 							      HDA_OUTPUT));
4055 			if (err < 0)
4056 				return err;
4057 			sprintf(name, "%s Playback Switch", chname[i]);
4058 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4059 					  HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4060 							      HDA_INPUT));
4061 			if (err < 0)
4062 				return err;
4063 		}
4064 	}
4065 	return 0;
4066 }
4067 
4068 /* add playback controls for speaker and HP outputs */
4069 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4070 					const char *pfx)
4071 {
4072 	hda_nid_t nid;
4073 	int err;
4074 	char name[32];
4075 
4076 	if (!pin)
4077 		return 0;
4078 
4079 	if (alc880_is_fixed_pin(pin)) {
4080 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4081 		/* specify the DAC as the extra output */
4082 		if (!spec->multiout.hp_nid)
4083 			spec->multiout.hp_nid = nid;
4084 		else
4085 			spec->multiout.extra_out_nid[0] = nid;
4086 		/* control HP volume/switch on the output mixer amp */
4087 		nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4088 		sprintf(name, "%s Playback Volume", pfx);
4089 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4090 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4091 		if (err < 0)
4092 			return err;
4093 		sprintf(name, "%s Playback Switch", pfx);
4094 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4095 				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4096 		if (err < 0)
4097 			return err;
4098 	} else if (alc880_is_multi_pin(pin)) {
4099 		/* set manual connection */
4100 		/* we have only a switch on HP-out PIN */
4101 		sprintf(name, "%s Playback Switch", pfx);
4102 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4103 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4104 		if (err < 0)
4105 			return err;
4106 	}
4107 	return 0;
4108 }
4109 
4110 /* create input playback/capture controls for the given pin */
4111 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4112 			    const char *ctlname,
4113 			    int idx, hda_nid_t mix_nid)
4114 {
4115 	char name[32];
4116 	int err;
4117 
4118 	sprintf(name, "%s Playback Volume", ctlname);
4119 	err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4120 			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4121 	if (err < 0)
4122 		return err;
4123 	sprintf(name, "%s Playback Switch", ctlname);
4124 	err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4125 			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4126 	if (err < 0)
4127 		return err;
4128 	return 0;
4129 }
4130 
4131 /* create playback/capture controls for input pins */
4132 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4133 						const struct auto_pin_cfg *cfg)
4134 {
4135 	struct hda_input_mux *imux = &spec->private_imux[0];
4136 	int i, err, idx;
4137 
4138 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4139 		if (alc880_is_input_pin(cfg->input_pins[i])) {
4140 			idx = alc880_input_pin_idx(cfg->input_pins[i]);
4141 			err = new_analog_input(spec, cfg->input_pins[i],
4142 					       auto_pin_cfg_labels[i],
4143 					       idx, 0x0b);
4144 			if (err < 0)
4145 				return err;
4146 			imux->items[imux->num_items].label =
4147 				auto_pin_cfg_labels[i];
4148 			imux->items[imux->num_items].index =
4149 				alc880_input_pin_idx(cfg->input_pins[i]);
4150 			imux->num_items++;
4151 		}
4152 	}
4153 	return 0;
4154 }
4155 
4156 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4157 			       unsigned int pin_type)
4158 {
4159 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4160 			    pin_type);
4161 	/* unmute pin */
4162 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4163 			    AMP_OUT_UNMUTE);
4164 }
4165 
4166 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4167 					      hda_nid_t nid, int pin_type,
4168 					      int dac_idx)
4169 {
4170 	alc_set_pin_output(codec, nid, pin_type);
4171 	/* need the manual connection? */
4172 	if (alc880_is_multi_pin(nid)) {
4173 		struct alc_spec *spec = codec->spec;
4174 		int idx = alc880_multi_pin_idx(nid);
4175 		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4176 				    AC_VERB_SET_CONNECT_SEL,
4177 				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4178 	}
4179 }
4180 
4181 static int get_pin_type(int line_out_type)
4182 {
4183 	if (line_out_type == AUTO_PIN_HP_OUT)
4184 		return PIN_HP;
4185 	else
4186 		return PIN_OUT;
4187 }
4188 
4189 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4190 {
4191 	struct alc_spec *spec = codec->spec;
4192 	int i;
4193 
4194 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4195 	for (i = 0; i < spec->autocfg.line_outs; i++) {
4196 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
4197 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
4198 		alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4199 	}
4200 }
4201 
4202 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4203 {
4204 	struct alc_spec *spec = codec->spec;
4205 	hda_nid_t pin;
4206 
4207 	pin = spec->autocfg.speaker_pins[0];
4208 	if (pin) /* connect to front */
4209 		alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4210 	pin = spec->autocfg.hp_pins[0];
4211 	if (pin) /* connect to front */
4212 		alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4213 }
4214 
4215 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4216 {
4217 	struct alc_spec *spec = codec->spec;
4218 	int i;
4219 
4220 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4221 		hda_nid_t nid = spec->autocfg.input_pins[i];
4222 		if (alc880_is_input_pin(nid)) {
4223 			alc_set_input_pin(codec, nid, i);
4224 			if (nid != ALC880_PIN_CD_NID &&
4225 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4226 				snd_hda_codec_write(codec, nid, 0,
4227 						    AC_VERB_SET_AMP_GAIN_MUTE,
4228 						    AMP_OUT_MUTE);
4229 		}
4230 	}
4231 }
4232 
4233 /* parse the BIOS configuration and set up the alc_spec */
4234 /* return 1 if successful, 0 if the proper config is not found,
4235  * or a negative error code
4236  */
4237 static int alc880_parse_auto_config(struct hda_codec *codec)
4238 {
4239 	struct alc_spec *spec = codec->spec;
4240 	int i, err;
4241 	static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4242 
4243 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4244 					   alc880_ignore);
4245 	if (err < 0)
4246 		return err;
4247 	if (!spec->autocfg.line_outs)
4248 		return 0; /* can't find valid BIOS pin config */
4249 
4250 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4251 	if (err < 0)
4252 		return err;
4253 	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4254 	if (err < 0)
4255 		return err;
4256 	err = alc880_auto_create_extra_out(spec,
4257 					   spec->autocfg.speaker_pins[0],
4258 					   "Speaker");
4259 	if (err < 0)
4260 		return err;
4261 	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4262 					   "Headphone");
4263 	if (err < 0)
4264 		return err;
4265 	err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4266 	if (err < 0)
4267 		return err;
4268 
4269 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4270 
4271 	/* check multiple SPDIF-out (for recent codecs) */
4272 	for (i = 0; i < spec->autocfg.dig_outs; i++) {
4273 		hda_nid_t dig_nid;
4274 		err = snd_hda_get_connections(codec,
4275 					      spec->autocfg.dig_out_pins[i],
4276 					      &dig_nid, 1);
4277 		if (err < 0)
4278 			continue;
4279 		if (!i)
4280 			spec->multiout.dig_out_nid = dig_nid;
4281 		else {
4282 			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4283 			spec->slave_dig_outs[i - 1] = dig_nid;
4284 			if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4285 				break;
4286 		}
4287 	}
4288 	if (spec->autocfg.dig_in_pin)
4289 		spec->dig_in_nid = ALC880_DIGIN_NID;
4290 
4291 	if (spec->kctls.list)
4292 		add_mixer(spec, spec->kctls.list);
4293 
4294 	add_verb(spec, alc880_volume_init_verbs);
4295 
4296 	spec->num_mux_defs = 1;
4297 	spec->input_mux = &spec->private_imux[0];
4298 
4299 	return 1;
4300 }
4301 
4302 /* additional initialization for auto-configuration model */
4303 static void alc880_auto_init(struct hda_codec *codec)
4304 {
4305 	struct alc_spec *spec = codec->spec;
4306 	alc880_auto_init_multi_out(codec);
4307 	alc880_auto_init_extra_out(codec);
4308 	alc880_auto_init_analog_input(codec);
4309 	if (spec->unsol_event)
4310 		alc_inithook(codec);
4311 }
4312 
4313 static void set_capture_mixer(struct alc_spec *spec)
4314 {
4315 	static struct snd_kcontrol_new *caps[2][3] = {
4316 		{ alc_capture_mixer_nosrc1,
4317 		  alc_capture_mixer_nosrc2,
4318 		  alc_capture_mixer_nosrc3 },
4319 		{ alc_capture_mixer1,
4320 		  alc_capture_mixer2,
4321 		  alc_capture_mixer3 },
4322 	};
4323 	if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4324 		int mux;
4325 		if (spec->input_mux && spec->input_mux->num_items > 1)
4326 			mux = 1;
4327 		else
4328 			mux = 0;
4329 		spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4330 	}
4331 }
4332 
4333 #define set_beep_amp(spec, nid, idx, dir) \
4334 	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4335 
4336 /*
4337  * OK, here we have finally the patch for ALC880
4338  */
4339 
4340 static int patch_alc880(struct hda_codec *codec)
4341 {
4342 	struct alc_spec *spec;
4343 	int board_config;
4344 	int err;
4345 
4346 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4347 	if (spec == NULL)
4348 		return -ENOMEM;
4349 
4350 	codec->spec = spec;
4351 
4352 	board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4353 						  alc880_models,
4354 						  alc880_cfg_tbl);
4355 	if (board_config < 0) {
4356 		printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4357 		       "trying auto-probe from BIOS...\n");
4358 		board_config = ALC880_AUTO;
4359 	}
4360 
4361 	if (board_config == ALC880_AUTO) {
4362 		/* automatic parse from the BIOS config */
4363 		err = alc880_parse_auto_config(codec);
4364 		if (err < 0) {
4365 			alc_free(codec);
4366 			return err;
4367 		} else if (!err) {
4368 			printk(KERN_INFO
4369 			       "hda_codec: Cannot set up configuration "
4370 			       "from BIOS.  Using 3-stack mode...\n");
4371 			board_config = ALC880_3ST;
4372 		}
4373 	}
4374 
4375 	err = snd_hda_attach_beep_device(codec, 0x1);
4376 	if (err < 0) {
4377 		alc_free(codec);
4378 		return err;
4379 	}
4380 
4381 	if (board_config != ALC880_AUTO)
4382 		setup_preset(spec, &alc880_presets[board_config]);
4383 
4384 	spec->stream_name_analog = "ALC880 Analog";
4385 	spec->stream_analog_playback = &alc880_pcm_analog_playback;
4386 	spec->stream_analog_capture = &alc880_pcm_analog_capture;
4387 	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4388 
4389 	spec->stream_name_digital = "ALC880 Digital";
4390 	spec->stream_digital_playback = &alc880_pcm_digital_playback;
4391 	spec->stream_digital_capture = &alc880_pcm_digital_capture;
4392 
4393 	if (!spec->adc_nids && spec->input_mux) {
4394 		/* check whether NID 0x07 is valid */
4395 		unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4396 		/* get type */
4397 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4398 		if (wcap != AC_WID_AUD_IN) {
4399 			spec->adc_nids = alc880_adc_nids_alt;
4400 			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4401 		} else {
4402 			spec->adc_nids = alc880_adc_nids;
4403 			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4404 		}
4405 	}
4406 	set_capture_mixer(spec);
4407 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4408 
4409 	spec->vmaster_nid = 0x0c;
4410 
4411 	codec->patch_ops = alc_patch_ops;
4412 	if (board_config == ALC880_AUTO)
4413 		spec->init_hook = alc880_auto_init;
4414 #ifdef CONFIG_SND_HDA_POWER_SAVE
4415 	if (!spec->loopback.amplist)
4416 		spec->loopback.amplist = alc880_loopbacks;
4417 #endif
4418 	codec->proc_widget_hook = print_realtek_coef;
4419 
4420 	return 0;
4421 }
4422 
4423 
4424 /*
4425  * ALC260 support
4426  */
4427 
4428 static hda_nid_t alc260_dac_nids[1] = {
4429 	/* front */
4430 	0x02,
4431 };
4432 
4433 static hda_nid_t alc260_adc_nids[1] = {
4434 	/* ADC0 */
4435 	0x04,
4436 };
4437 
4438 static hda_nid_t alc260_adc_nids_alt[1] = {
4439 	/* ADC1 */
4440 	0x05,
4441 };
4442 
4443 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4444  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4445  */
4446 static hda_nid_t alc260_dual_adc_nids[2] = {
4447 	/* ADC0, ADC1 */
4448 	0x04, 0x05
4449 };
4450 
4451 #define ALC260_DIGOUT_NID	0x03
4452 #define ALC260_DIGIN_NID	0x06
4453 
4454 static struct hda_input_mux alc260_capture_source = {
4455 	.num_items = 4,
4456 	.items = {
4457 		{ "Mic", 0x0 },
4458 		{ "Front Mic", 0x1 },
4459 		{ "Line", 0x2 },
4460 		{ "CD", 0x4 },
4461 	},
4462 };
4463 
4464 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4465  * headphone jack and the internal CD lines since these are the only pins at
4466  * which audio can appear.  For flexibility, also allow the option of
4467  * recording the mixer output on the second ADC (ADC0 doesn't have a
4468  * connection to the mixer output).
4469  */
4470 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4471 	{
4472 		.num_items = 3,
4473 		.items = {
4474 			{ "Mic/Line", 0x0 },
4475 			{ "CD", 0x4 },
4476 			{ "Headphone", 0x2 },
4477 		},
4478 	},
4479 	{
4480 		.num_items = 4,
4481 		.items = {
4482 			{ "Mic/Line", 0x0 },
4483 			{ "CD", 0x4 },
4484 			{ "Headphone", 0x2 },
4485 			{ "Mixer", 0x5 },
4486 		},
4487 	},
4488 
4489 };
4490 
4491 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4492  * the Fujitsu S702x, but jacks are marked differently.
4493  */
4494 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4495 	{
4496 		.num_items = 4,
4497 		.items = {
4498 			{ "Mic", 0x0 },
4499 			{ "Line", 0x2 },
4500 			{ "CD", 0x4 },
4501 			{ "Headphone", 0x5 },
4502 		},
4503 	},
4504 	{
4505 		.num_items = 5,
4506 		.items = {
4507 			{ "Mic", 0x0 },
4508 			{ "Line", 0x2 },
4509 			{ "CD", 0x4 },
4510 			{ "Headphone", 0x6 },
4511 			{ "Mixer", 0x5 },
4512 		},
4513 	},
4514 };
4515 
4516 /* Maxdata Favorit 100XS */
4517 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4518 	{
4519 		.num_items = 2,
4520 		.items = {
4521 			{ "Line/Mic", 0x0 },
4522 			{ "CD", 0x4 },
4523 		},
4524 	},
4525 	{
4526 		.num_items = 3,
4527 		.items = {
4528 			{ "Line/Mic", 0x0 },
4529 			{ "CD", 0x4 },
4530 			{ "Mixer", 0x5 },
4531 		},
4532 	},
4533 };
4534 
4535 /*
4536  * This is just place-holder, so there's something for alc_build_pcms to look
4537  * at when it calculates the maximum number of channels. ALC260 has no mixer
4538  * element which allows changing the channel mode, so the verb list is
4539  * never used.
4540  */
4541 static struct hda_channel_mode alc260_modes[1] = {
4542 	{ 2, NULL },
4543 };
4544 
4545 
4546 /* Mixer combinations
4547  *
4548  * basic: base_output + input + pc_beep + capture
4549  * HP: base_output + input + capture_alt
4550  * HP_3013: hp_3013 + input + capture
4551  * fujitsu: fujitsu + capture
4552  * acer: acer + capture
4553  */
4554 
4555 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4556 	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4557 	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4558 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4559 	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4560 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4561 	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4562 	{ } /* end */
4563 };
4564 
4565 static struct snd_kcontrol_new alc260_input_mixer[] = {
4566 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4567 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4568 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4569 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4570 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4571 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4572 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4573 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4574 	{ } /* end */
4575 };
4576 
4577 /* update HP, line and mono out pins according to the master switch */
4578 static void alc260_hp_master_update(struct hda_codec *codec,
4579 				    hda_nid_t hp, hda_nid_t line,
4580 				    hda_nid_t mono)
4581 {
4582 	struct alc_spec *spec = codec->spec;
4583 	unsigned int val = spec->master_sw ? PIN_HP : 0;
4584 	/* change HP and line-out pins */
4585 	snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4586 			    val);
4587 	snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4588 			    val);
4589 	/* mono (speaker) depending on the HP jack sense */
4590 	val = (val && !spec->jack_present) ? PIN_OUT : 0;
4591 	snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4592 			    val);
4593 }
4594 
4595 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4596 				   struct snd_ctl_elem_value *ucontrol)
4597 {
4598 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4599 	struct alc_spec *spec = codec->spec;
4600 	*ucontrol->value.integer.value = spec->master_sw;
4601 	return 0;
4602 }
4603 
4604 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4605 				   struct snd_ctl_elem_value *ucontrol)
4606 {
4607 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4608 	struct alc_spec *spec = codec->spec;
4609 	int val = !!*ucontrol->value.integer.value;
4610 	hda_nid_t hp, line, mono;
4611 
4612 	if (val == spec->master_sw)
4613 		return 0;
4614 	spec->master_sw = val;
4615 	hp = (kcontrol->private_value >> 16) & 0xff;
4616 	line = (kcontrol->private_value >> 8) & 0xff;
4617 	mono = kcontrol->private_value & 0xff;
4618 	alc260_hp_master_update(codec, hp, line, mono);
4619 	return 1;
4620 }
4621 
4622 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4623 	{
4624 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4625 		.name = "Master Playback Switch",
4626 		.info = snd_ctl_boolean_mono_info,
4627 		.get = alc260_hp_master_sw_get,
4628 		.put = alc260_hp_master_sw_put,
4629 		.private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4630 	},
4631 	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4632 	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4633 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4634 	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4635 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4636 			      HDA_OUTPUT),
4637 	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4638 	{ } /* end */
4639 };
4640 
4641 static struct hda_verb alc260_hp_unsol_verbs[] = {
4642 	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4643 	{},
4644 };
4645 
4646 static void alc260_hp_automute(struct hda_codec *codec)
4647 {
4648 	struct alc_spec *spec = codec->spec;
4649 	unsigned int present;
4650 
4651 	present = snd_hda_codec_read(codec, 0x10, 0,
4652 				     AC_VERB_GET_PIN_SENSE, 0);
4653 	spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4654 	alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4655 }
4656 
4657 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4658 {
4659 	if ((res >> 26) == ALC880_HP_EVENT)
4660 		alc260_hp_automute(codec);
4661 }
4662 
4663 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4664 	{
4665 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4666 		.name = "Master Playback Switch",
4667 		.info = snd_ctl_boolean_mono_info,
4668 		.get = alc260_hp_master_sw_get,
4669 		.put = alc260_hp_master_sw_put,
4670 		.private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4671 	},
4672 	HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4673 	HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4674 	HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4675 	HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4676 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4677 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4678 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4679 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4680 	{ } /* end */
4681 };
4682 
4683 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4684 	.ops = &snd_hda_bind_vol,
4685 	.values = {
4686 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4687 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4688 		HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4689 		0
4690 	},
4691 };
4692 
4693 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4694 	.ops = &snd_hda_bind_sw,
4695 	.values = {
4696 		HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4697 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4698 		0
4699 	},
4700 };
4701 
4702 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4703 	HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4704 	HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4705 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4706 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4707 	{ } /* end */
4708 };
4709 
4710 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4711 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4712 	{},
4713 };
4714 
4715 static void alc260_hp_3013_automute(struct hda_codec *codec)
4716 {
4717 	struct alc_spec *spec = codec->spec;
4718 	unsigned int present;
4719 
4720 	present = snd_hda_codec_read(codec, 0x15, 0,
4721 				     AC_VERB_GET_PIN_SENSE, 0);
4722 	spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4723 	alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4724 }
4725 
4726 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4727 				       unsigned int res)
4728 {
4729 	if ((res >> 26) == ALC880_HP_EVENT)
4730 		alc260_hp_3013_automute(codec);
4731 }
4732 
4733 static void alc260_hp_3012_automute(struct hda_codec *codec)
4734 {
4735 	unsigned int present, bits;
4736 
4737 	present = snd_hda_codec_read(codec, 0x10, 0,
4738 			AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4739 
4740 	bits = present ? 0 : PIN_OUT;
4741 	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4742 			    bits);
4743 	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4744 			    bits);
4745 	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4746 			    bits);
4747 }
4748 
4749 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4750 				       unsigned int res)
4751 {
4752 	if ((res >> 26) == ALC880_HP_EVENT)
4753 		alc260_hp_3012_automute(codec);
4754 }
4755 
4756 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4757  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4758  */
4759 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4760 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4761 	HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4762 	ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4763 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4764 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4765 	HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4766 	HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4767 	ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4768 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4769 	HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4770 	{ } /* end */
4771 };
4772 
4773 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4774  * versions of the ALC260 don't act on requests to enable mic bias from NID
4775  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4776  * datasheet doesn't mention this restriction.  At this stage it's not clear
4777  * whether this behaviour is intentional or is a hardware bug in chip
4778  * revisions available in early 2006.  Therefore for now allow the
4779  * "Headphone Jack Mode" control to span all choices, but if it turns out
4780  * that the lack of mic bias for this NID is intentional we could change the
4781  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4782  *
4783  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4784  * don't appear to make the mic bias available from the "line" jack, even
4785  * though the NID used for this jack (0x14) can supply it.  The theory is
4786  * that perhaps Acer have included blocking capacitors between the ALC260
4787  * and the output jack.  If this turns out to be the case for all such
4788  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4789  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4790  *
4791  * The C20x Tablet series have a mono internal speaker which is controlled
4792  * via the chip's Mono sum widget and pin complex, so include the necessary
4793  * controls for such models.  On models without a "mono speaker" the control
4794  * won't do anything.
4795  */
4796 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4797 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4798 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4799 	ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4800 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4801 			      HDA_OUTPUT),
4802 	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4803 			   HDA_INPUT),
4804 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4805 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4806 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4807 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4808 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4809 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4810 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4811 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4812 	{ } /* end */
4813 };
4814 
4815 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
4816  */
4817 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
4818 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4819 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4820 	ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4821 	HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4822 	HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4823 	ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4824 	{ } /* end */
4825 };
4826 
4827 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4828  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4829  */
4830 static struct snd_kcontrol_new alc260_will_mixer[] = {
4831 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4832 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4833 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4834 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4835 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4836 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4837 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4838 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4839 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4840 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4841 	{ } /* end */
4842 };
4843 
4844 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4845  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4846  */
4847 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4848 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4849 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4850 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4851 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4852 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4853 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4854 	HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4855 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4856 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4857 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4858 	{ } /* end */
4859 };
4860 
4861 /*
4862  * initialization verbs
4863  */
4864 static struct hda_verb alc260_init_verbs[] = {
4865 	/* Line In pin widget for input */
4866 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4867 	/* CD pin widget for input */
4868 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4869 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
4870 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4871 	/* Mic2 (front panel) pin widget for input and vref at 80% */
4872 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4873 	/* LINE-2 is used for line-out in rear */
4874 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4875 	/* select line-out */
4876 	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4877 	/* LINE-OUT pin */
4878 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4879 	/* enable HP */
4880 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4881 	/* enable Mono */
4882 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4883 	/* mute capture amp left and right */
4884 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4885 	/* set connection select to line in (default select for this ADC) */
4886 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4887 	/* mute capture amp left and right */
4888 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4889 	/* set connection select to line in (default select for this ADC) */
4890 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4891 	/* set vol=0 Line-Out mixer amp left and right */
4892 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4893 	/* unmute pin widget amp left and right (no gain on this amp) */
4894 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4895 	/* set vol=0 HP mixer amp left and right */
4896 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4897 	/* unmute pin widget amp left and right (no gain on this amp) */
4898 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4899 	/* set vol=0 Mono mixer amp left and right */
4900 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4901 	/* unmute pin widget amp left and right (no gain on this amp) */
4902 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4903 	/* unmute LINE-2 out pin */
4904 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4905 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4906 	 * Line In 2 = 0x03
4907 	 */
4908 	/* mute analog inputs */
4909 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4910 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4911 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4912 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4913 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4914 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4915 	/* mute Front out path */
4916 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4917 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4918 	/* mute Headphone out path */
4919 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4920 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4921 	/* mute Mono out path */
4922 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4923 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4924 	{ }
4925 };
4926 
4927 #if 0 /* should be identical with alc260_init_verbs? */
4928 static struct hda_verb alc260_hp_init_verbs[] = {
4929 	/* Headphone and output */
4930 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4931 	/* mono output */
4932 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4933 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
4934 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4935 	/* Mic2 (front panel) pin widget for input and vref at 80% */
4936 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4937 	/* Line In pin widget for input */
4938 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4939 	/* Line-2 pin widget for output */
4940 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4941 	/* CD pin widget for input */
4942 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4943 	/* unmute amp left and right */
4944 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4945 	/* set connection select to line in (default select for this ADC) */
4946 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4947 	/* unmute Line-Out mixer amp left and right (volume = 0) */
4948 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4949 	/* mute pin widget amp left and right (no gain on this amp) */
4950 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4951 	/* unmute HP mixer amp left and right (volume = 0) */
4952 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4953 	/* mute pin widget amp left and right (no gain on this amp) */
4954 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4955 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4956 	 * Line In 2 = 0x03
4957 	 */
4958 	/* mute analog inputs */
4959 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4960 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4961 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4962 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4963 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4964 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4965 	/* Unmute Front out path */
4966 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4967 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4968 	/* Unmute Headphone out path */
4969 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4970 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4971 	/* Unmute Mono out path */
4972 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4973 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4974 	{ }
4975 };
4976 #endif
4977 
4978 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4979 	/* Line out and output */
4980 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4981 	/* mono output */
4982 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4983 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
4984 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4985 	/* Mic2 (front panel) pin widget for input and vref at 80% */
4986 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4987 	/* Line In pin widget for input */
4988 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4989 	/* Headphone pin widget for output */
4990 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4991 	/* CD pin widget for input */
4992 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4993 	/* unmute amp left and right */
4994 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4995 	/* set connection select to line in (default select for this ADC) */
4996 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4997 	/* unmute Line-Out mixer amp left and right (volume = 0) */
4998 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4999 	/* mute pin widget amp left and right (no gain on this amp) */
5000 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5001 	/* unmute HP mixer amp left and right (volume = 0) */
5002 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5003 	/* mute pin widget amp left and right (no gain on this amp) */
5004 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5005 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5006 	 * Line In 2 = 0x03
5007 	 */
5008 	/* mute analog inputs */
5009 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5010 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5011 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5012 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5013 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5014 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5015 	/* Unmute Front out path */
5016 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5017 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5018 	/* Unmute Headphone out path */
5019 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5020 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5021 	/* Unmute Mono out path */
5022 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5023 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5024 	{ }
5025 };
5026 
5027 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5028  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5029  * audio = 0x16, internal speaker = 0x10.
5030  */
5031 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5032 	/* Disable all GPIOs */
5033 	{0x01, AC_VERB_SET_GPIO_MASK, 0},
5034 	/* Internal speaker is connected to headphone pin */
5035 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5036 	/* Headphone/Line-out jack connects to Line1 pin; make it an output */
5037 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5038 	/* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5039 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5040 	/* Ensure all other unused pins are disabled and muted. */
5041 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5042 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5043 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5044 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5045 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5046 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5047 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5048 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5049 
5050 	/* Disable digital (SPDIF) pins */
5051 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5052 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5053 
5054 	/* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5055 	 * when acting as an output.
5056 	 */
5057 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5058 
5059 	/* Start with output sum widgets muted and their output gains at min */
5060 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5061 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5062 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5063 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5064 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5065 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5066 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5067 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5068 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5069 
5070 	/* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5071 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5072 	/* Unmute Line1 pin widget output buffer since it starts as an output.
5073 	 * If the pin mode is changed by the user the pin mode control will
5074 	 * take care of enabling the pin's input/output buffers as needed.
5075 	 * Therefore there's no need to enable the input buffer at this
5076 	 * stage.
5077 	 */
5078 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5079 	/* Unmute input buffer of pin widget used for Line-in (no equiv
5080 	 * mixer ctrl)
5081 	 */
5082 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5083 
5084 	/* Mute capture amp left and right */
5085 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5086 	/* Set ADC connection select to match default mixer setting - line
5087 	 * in (on mic1 pin)
5088 	 */
5089 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5090 
5091 	/* Do the same for the second ADC: mute capture input amp and
5092 	 * set ADC connection to line in (on mic1 pin)
5093 	 */
5094 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5095 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5096 
5097 	/* Mute all inputs to mixer widget (even unconnected ones) */
5098 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5099 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5100 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5101 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5102 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5103 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5104 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5105 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5106 
5107 	{ }
5108 };
5109 
5110 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5111  * similar laptops (adapted from Fujitsu init verbs).
5112  */
5113 static struct hda_verb alc260_acer_init_verbs[] = {
5114 	/* On TravelMate laptops, GPIO 0 enables the internal speaker and
5115 	 * the headphone jack.  Turn this on and rely on the standard mute
5116 	 * methods whenever the user wants to turn these outputs off.
5117 	 */
5118 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5119 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5120 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5121 	/* Internal speaker/Headphone jack is connected to Line-out pin */
5122 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5123 	/* Internal microphone/Mic jack is connected to Mic1 pin */
5124 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5125 	/* Line In jack is connected to Line1 pin */
5126 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5127 	/* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5128 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5129 	/* Ensure all other unused pins are disabled and muted. */
5130 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5131 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5132 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5133 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5134 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5135 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5136 	/* Disable digital (SPDIF) pins */
5137 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5138 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5139 
5140 	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5141 	 * bus when acting as outputs.
5142 	 */
5143 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5144 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5145 
5146 	/* Start with output sum widgets muted and their output gains at min */
5147 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5148 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5149 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5150 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5151 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5152 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5153 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5154 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5155 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5156 
5157 	/* Unmute Line-out pin widget amp left and right
5158 	 * (no equiv mixer ctrl)
5159 	 */
5160 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5161 	/* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5162 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5163 	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
5164 	 * inputs. If the pin mode is changed by the user the pin mode control
5165 	 * will take care of enabling the pin's input/output buffers as needed.
5166 	 * Therefore there's no need to enable the input buffer at this
5167 	 * stage.
5168 	 */
5169 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5170 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5171 
5172 	/* Mute capture amp left and right */
5173 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5174 	/* Set ADC connection select to match default mixer setting - mic
5175 	 * (on mic1 pin)
5176 	 */
5177 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5178 
5179 	/* Do similar with the second ADC: mute capture input amp and
5180 	 * set ADC connection to mic to match ALSA's default state.
5181 	 */
5182 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5183 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5184 
5185 	/* Mute all inputs to mixer widget (even unconnected ones) */
5186 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5187 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5188 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5189 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5190 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5191 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5192 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5193 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5194 
5195 	{ }
5196 };
5197 
5198 /* Initialisation sequence for Maxdata Favorit 100XS
5199  * (adapted from Acer init verbs).
5200  */
5201 static struct hda_verb alc260_favorit100_init_verbs[] = {
5202 	/* GPIO 0 enables the output jack.
5203 	 * Turn this on and rely on the standard mute
5204 	 * methods whenever the user wants to turn these outputs off.
5205 	 */
5206 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5207 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5208 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5209 	/* Line/Mic input jack is connected to Mic1 pin */
5210 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5211 	/* Ensure all other unused pins are disabled and muted. */
5212 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5213 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5214 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5215 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5216 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5217 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5218 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5219 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5220 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5221 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5222 	/* Disable digital (SPDIF) pins */
5223 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5224 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5225 
5226 	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5227 	 * bus when acting as outputs.
5228 	 */
5229 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5230 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5231 
5232 	/* Start with output sum widgets muted and their output gains at min */
5233 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5234 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5235 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5236 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5237 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5238 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5239 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5240 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5241 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5242 
5243 	/* Unmute Line-out pin widget amp left and right
5244 	 * (no equiv mixer ctrl)
5245 	 */
5246 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5247 	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
5248 	 * inputs. If the pin mode is changed by the user the pin mode control
5249 	 * will take care of enabling the pin's input/output buffers as needed.
5250 	 * Therefore there's no need to enable the input buffer at this
5251 	 * stage.
5252 	 */
5253 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5254 
5255 	/* Mute capture amp left and right */
5256 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5257 	/* Set ADC connection select to match default mixer setting - mic
5258 	 * (on mic1 pin)
5259 	 */
5260 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5261 
5262 	/* Do similar with the second ADC: mute capture input amp and
5263 	 * set ADC connection to mic to match ALSA's default state.
5264 	 */
5265 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5266 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5267 
5268 	/* Mute all inputs to mixer widget (even unconnected ones) */
5269 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5270 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5271 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5272 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5273 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5274 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5275 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5276 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5277 
5278 	{ }
5279 };
5280 
5281 static struct hda_verb alc260_will_verbs[] = {
5282 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5283 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5284 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5285 	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5286 	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5287 	{0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5288 	{}
5289 };
5290 
5291 static struct hda_verb alc260_replacer_672v_verbs[] = {
5292 	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5293 	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5294 	{0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5295 
5296 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5297 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5298 	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5299 
5300 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5301 	{}
5302 };
5303 
5304 /* toggle speaker-output according to the hp-jack state */
5305 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5306 {
5307         unsigned int present;
5308 
5309 	/* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5310         present = snd_hda_codec_read(codec, 0x0f, 0,
5311                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5312 	if (present) {
5313 		snd_hda_codec_write_cache(codec, 0x01, 0,
5314 					  AC_VERB_SET_GPIO_DATA, 1);
5315 		snd_hda_codec_write_cache(codec, 0x0f, 0,
5316 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
5317 					  PIN_HP);
5318 	} else {
5319 		snd_hda_codec_write_cache(codec, 0x01, 0,
5320 					  AC_VERB_SET_GPIO_DATA, 0);
5321 		snd_hda_codec_write_cache(codec, 0x0f, 0,
5322 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
5323 					  PIN_OUT);
5324 	}
5325 }
5326 
5327 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5328                                        unsigned int res)
5329 {
5330         if ((res >> 26) == ALC880_HP_EVENT)
5331                 alc260_replacer_672v_automute(codec);
5332 }
5333 
5334 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5335 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5336 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5337 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5338 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5339 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5340 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5341 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5342 	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5343 	{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5344 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5345 	{}
5346 };
5347 
5348 /* Test configuration for debugging, modelled after the ALC880 test
5349  * configuration.
5350  */
5351 #ifdef CONFIG_SND_DEBUG
5352 static hda_nid_t alc260_test_dac_nids[1] = {
5353 	0x02,
5354 };
5355 static hda_nid_t alc260_test_adc_nids[2] = {
5356 	0x04, 0x05,
5357 };
5358 /* For testing the ALC260, each input MUX needs its own definition since
5359  * the signal assignments are different.  This assumes that the first ADC
5360  * is NID 0x04.
5361  */
5362 static struct hda_input_mux alc260_test_capture_sources[2] = {
5363 	{
5364 		.num_items = 7,
5365 		.items = {
5366 			{ "MIC1 pin", 0x0 },
5367 			{ "MIC2 pin", 0x1 },
5368 			{ "LINE1 pin", 0x2 },
5369 			{ "LINE2 pin", 0x3 },
5370 			{ "CD pin", 0x4 },
5371 			{ "LINE-OUT pin", 0x5 },
5372 			{ "HP-OUT pin", 0x6 },
5373 		},
5374         },
5375 	{
5376 		.num_items = 8,
5377 		.items = {
5378 			{ "MIC1 pin", 0x0 },
5379 			{ "MIC2 pin", 0x1 },
5380 			{ "LINE1 pin", 0x2 },
5381 			{ "LINE2 pin", 0x3 },
5382 			{ "CD pin", 0x4 },
5383 			{ "Mixer", 0x5 },
5384 			{ "LINE-OUT pin", 0x6 },
5385 			{ "HP-OUT pin", 0x7 },
5386 		},
5387         },
5388 };
5389 static struct snd_kcontrol_new alc260_test_mixer[] = {
5390 	/* Output driver widgets */
5391 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5392 	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5393 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5394 	HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5395 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5396 	HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5397 
5398 	/* Modes for retasking pin widgets
5399 	 * Note: the ALC260 doesn't seem to act on requests to enable mic
5400          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5401          * mention this restriction.  At this stage it's not clear whether
5402          * this behaviour is intentional or is a hardware bug in chip
5403          * revisions available at least up until early 2006.  Therefore for
5404          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5405          * choices, but if it turns out that the lack of mic bias for these
5406          * NIDs is intentional we could change their modes from
5407          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5408 	 */
5409 	ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5410 	ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5411 	ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5412 	ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5413 	ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5414 	ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5415 
5416 	/* Loopback mixer controls */
5417 	HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5418 	HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5419 	HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5420 	HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5421 	HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5422 	HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5423 	HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5424 	HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5425 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5426 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5427 	HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5428 	HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5429 	HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5430 	HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5431 
5432 	/* Controls for GPIO pins, assuming they are configured as outputs */
5433 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5434 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5435 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5436 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5437 
5438 	/* Switches to allow the digital IO pins to be enabled.  The datasheet
5439 	 * is ambigious as to which NID is which; testing on laptops which
5440 	 * make this output available should provide clarification.
5441 	 */
5442 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5443 	ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5444 
5445 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
5446 	 * this output to turn on an external amplifier.
5447 	 */
5448 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5449 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5450 
5451 	{ } /* end */
5452 };
5453 static struct hda_verb alc260_test_init_verbs[] = {
5454 	/* Enable all GPIOs as outputs with an initial value of 0 */
5455 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5456 	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5457 	{0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5458 
5459 	/* Enable retasking pins as output, initially without power amp */
5460 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5461 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5462 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5463 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5464 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5465 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5466 
5467 	/* Disable digital (SPDIF) pins initially, but users can enable
5468 	 * them via a mixer switch.  In the case of SPDIF-out, this initverb
5469 	 * payload also sets the generation to 0, output to be in "consumer"
5470 	 * PCM format, copyright asserted, no pre-emphasis and no validity
5471 	 * control.
5472 	 */
5473 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5474 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5475 
5476 	/* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5477 	 * OUT1 sum bus when acting as an output.
5478 	 */
5479 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5480 	{0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5481 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5482 	{0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5483 
5484 	/* Start with output sum widgets muted and their output gains at min */
5485 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5486 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5487 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5488 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5489 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5490 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5491 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5492 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5493 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5494 
5495 	/* Unmute retasking pin widget output buffers since the default
5496 	 * state appears to be output.  As the pin mode is changed by the
5497 	 * user the pin mode control will take care of enabling the pin's
5498 	 * input/output buffers as needed.
5499 	 */
5500 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5501 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5502 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5503 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5504 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5505 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5506 	/* Also unmute the mono-out pin widget */
5507 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5508 
5509 	/* Mute capture amp left and right */
5510 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5511 	/* Set ADC connection select to match default mixer setting (mic1
5512 	 * pin)
5513 	 */
5514 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5515 
5516 	/* Do the same for the second ADC: mute capture input amp and
5517 	 * set ADC connection to mic1 pin
5518 	 */
5519 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5520 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5521 
5522 	/* Mute all inputs to mixer widget (even unconnected ones) */
5523 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5524 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5525 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5526 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5527 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5528 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5529 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5530 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5531 
5532 	{ }
5533 };
5534 #endif
5535 
5536 #define alc260_pcm_analog_playback	alc880_pcm_analog_alt_playback
5537 #define alc260_pcm_analog_capture	alc880_pcm_analog_capture
5538 
5539 #define alc260_pcm_digital_playback	alc880_pcm_digital_playback
5540 #define alc260_pcm_digital_capture	alc880_pcm_digital_capture
5541 
5542 /*
5543  * for BIOS auto-configuration
5544  */
5545 
5546 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5547 					const char *pfx, int *vol_bits)
5548 {
5549 	hda_nid_t nid_vol;
5550 	unsigned long vol_val, sw_val;
5551 	char name[32];
5552 	int err;
5553 
5554 	if (nid >= 0x0f && nid < 0x11) {
5555 		nid_vol = nid - 0x7;
5556 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5557 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5558 	} else if (nid == 0x11) {
5559 		nid_vol = nid - 0x7;
5560 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5561 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5562 	} else if (nid >= 0x12 && nid <= 0x15) {
5563 		nid_vol = 0x08;
5564 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5565 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5566 	} else
5567 		return 0; /* N/A */
5568 
5569 	if (!(*vol_bits & (1 << nid_vol))) {
5570 		/* first control for the volume widget */
5571 		snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5572 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5573 		if (err < 0)
5574 			return err;
5575 		*vol_bits |= (1 << nid_vol);
5576 	}
5577 	snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5578 	err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5579 	if (err < 0)
5580 		return err;
5581 	return 1;
5582 }
5583 
5584 /* add playback controls from the parsed DAC table */
5585 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5586 					     const struct auto_pin_cfg *cfg)
5587 {
5588 	hda_nid_t nid;
5589 	int err;
5590 	int vols = 0;
5591 
5592 	spec->multiout.num_dacs = 1;
5593 	spec->multiout.dac_nids = spec->private_dac_nids;
5594 	spec->multiout.dac_nids[0] = 0x02;
5595 
5596 	nid = cfg->line_out_pins[0];
5597 	if (nid) {
5598 		err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5599 		if (err < 0)
5600 			return err;
5601 	}
5602 
5603 	nid = cfg->speaker_pins[0];
5604 	if (nid) {
5605 		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5606 		if (err < 0)
5607 			return err;
5608 	}
5609 
5610 	nid = cfg->hp_pins[0];
5611 	if (nid) {
5612 		err = alc260_add_playback_controls(spec, nid, "Headphone",
5613 						   &vols);
5614 		if (err < 0)
5615 			return err;
5616 	}
5617 	return 0;
5618 }
5619 
5620 /* create playback/capture controls for input pins */
5621 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5622 						const struct auto_pin_cfg *cfg)
5623 {
5624 	struct hda_input_mux *imux = &spec->private_imux[0];
5625 	int i, err, idx;
5626 
5627 	for (i = 0; i < AUTO_PIN_LAST; i++) {
5628 		if (cfg->input_pins[i] >= 0x12) {
5629 			idx = cfg->input_pins[i] - 0x12;
5630 			err = new_analog_input(spec, cfg->input_pins[i],
5631 					       auto_pin_cfg_labels[i], idx,
5632 					       0x07);
5633 			if (err < 0)
5634 				return err;
5635 			imux->items[imux->num_items].label =
5636 				auto_pin_cfg_labels[i];
5637 			imux->items[imux->num_items].index = idx;
5638 			imux->num_items++;
5639 		}
5640 		if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5641 			idx = cfg->input_pins[i] - 0x09;
5642 			err = new_analog_input(spec, cfg->input_pins[i],
5643 					       auto_pin_cfg_labels[i], idx,
5644 					       0x07);
5645 			if (err < 0)
5646 				return err;
5647 			imux->items[imux->num_items].label =
5648 				auto_pin_cfg_labels[i];
5649 			imux->items[imux->num_items].index = idx;
5650 			imux->num_items++;
5651 		}
5652 	}
5653 	return 0;
5654 }
5655 
5656 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5657 					      hda_nid_t nid, int pin_type,
5658 					      int sel_idx)
5659 {
5660 	alc_set_pin_output(codec, nid, pin_type);
5661 	/* need the manual connection? */
5662 	if (nid >= 0x12) {
5663 		int idx = nid - 0x12;
5664 		snd_hda_codec_write(codec, idx + 0x0b, 0,
5665 				    AC_VERB_SET_CONNECT_SEL, sel_idx);
5666 	}
5667 }
5668 
5669 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5670 {
5671 	struct alc_spec *spec = codec->spec;
5672 	hda_nid_t nid;
5673 
5674 	alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5675 	nid = spec->autocfg.line_out_pins[0];
5676 	if (nid) {
5677 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
5678 		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5679 	}
5680 
5681 	nid = spec->autocfg.speaker_pins[0];
5682 	if (nid)
5683 		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5684 
5685 	nid = spec->autocfg.hp_pins[0];
5686 	if (nid)
5687 		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5688 }
5689 
5690 #define ALC260_PIN_CD_NID		0x16
5691 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5692 {
5693 	struct alc_spec *spec = codec->spec;
5694 	int i;
5695 
5696 	for (i = 0; i < AUTO_PIN_LAST; i++) {
5697 		hda_nid_t nid = spec->autocfg.input_pins[i];
5698 		if (nid >= 0x12) {
5699 			alc_set_input_pin(codec, nid, i);
5700 			if (nid != ALC260_PIN_CD_NID &&
5701 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5702 				snd_hda_codec_write(codec, nid, 0,
5703 						    AC_VERB_SET_AMP_GAIN_MUTE,
5704 						    AMP_OUT_MUTE);
5705 		}
5706 	}
5707 }
5708 
5709 /*
5710  * generic initialization of ADC, input mixers and output mixers
5711  */
5712 static struct hda_verb alc260_volume_init_verbs[] = {
5713 	/*
5714 	 * Unmute ADC0-1 and set the default input to mic-in
5715 	 */
5716 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5717 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5718 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5719 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5720 
5721 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5722 	 * mixer widget
5723 	 * Note: PASD motherboards uses the Line In 2 as the input for
5724 	 * front panel mic (mic 2)
5725 	 */
5726 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5727 	/* mute analog inputs */
5728 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5729 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5730 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5731 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5732 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5733 
5734 	/*
5735 	 * Set up output mixers (0x08 - 0x0a)
5736 	 */
5737 	/* set vol=0 to output mixers */
5738 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5739 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5740 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5741 	/* set up input amps for analog loopback */
5742 	/* Amp Indices: DAC = 0, mixer = 1 */
5743 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5744 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5745 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5746 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5747 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5748 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5749 
5750 	{ }
5751 };
5752 
5753 static int alc260_parse_auto_config(struct hda_codec *codec)
5754 {
5755 	struct alc_spec *spec = codec->spec;
5756 	int err;
5757 	static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5758 
5759 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5760 					   alc260_ignore);
5761 	if (err < 0)
5762 		return err;
5763 	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5764 	if (err < 0)
5765 		return err;
5766 	if (!spec->kctls.list)
5767 		return 0; /* can't find valid BIOS pin config */
5768 	err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5769 	if (err < 0)
5770 		return err;
5771 
5772 	spec->multiout.max_channels = 2;
5773 
5774 	if (spec->autocfg.dig_outs)
5775 		spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5776 	if (spec->kctls.list)
5777 		add_mixer(spec, spec->kctls.list);
5778 
5779 	add_verb(spec, alc260_volume_init_verbs);
5780 
5781 	spec->num_mux_defs = 1;
5782 	spec->input_mux = &spec->private_imux[0];
5783 
5784 	return 1;
5785 }
5786 
5787 /* additional initialization for auto-configuration model */
5788 static void alc260_auto_init(struct hda_codec *codec)
5789 {
5790 	struct alc_spec *spec = codec->spec;
5791 	alc260_auto_init_multi_out(codec);
5792 	alc260_auto_init_analog_input(codec);
5793 	if (spec->unsol_event)
5794 		alc_inithook(codec);
5795 }
5796 
5797 #ifdef CONFIG_SND_HDA_POWER_SAVE
5798 static struct hda_amp_list alc260_loopbacks[] = {
5799 	{ 0x07, HDA_INPUT, 0 },
5800 	{ 0x07, HDA_INPUT, 1 },
5801 	{ 0x07, HDA_INPUT, 2 },
5802 	{ 0x07, HDA_INPUT, 3 },
5803 	{ 0x07, HDA_INPUT, 4 },
5804 	{ } /* end */
5805 };
5806 #endif
5807 
5808 /*
5809  * ALC260 configurations
5810  */
5811 static const char *alc260_models[ALC260_MODEL_LAST] = {
5812 	[ALC260_BASIC]		= "basic",
5813 	[ALC260_HP]		= "hp",
5814 	[ALC260_HP_3013]	= "hp-3013",
5815 	[ALC260_HP_DC7600]	= "hp-dc7600",
5816 	[ALC260_FUJITSU_S702X]	= "fujitsu",
5817 	[ALC260_ACER]		= "acer",
5818 	[ALC260_WILL]		= "will",
5819 	[ALC260_REPLACER_672V]	= "replacer",
5820 	[ALC260_FAVORIT100]	= "favorit100",
5821 #ifdef CONFIG_SND_DEBUG
5822 	[ALC260_TEST]		= "test",
5823 #endif
5824 	[ALC260_AUTO]		= "auto",
5825 };
5826 
5827 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5828 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5829 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5830 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
5831 	SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5832 	SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5833 	SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5834 	SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5835 	SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5836 	SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5837 	SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5838 	SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5839 	SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5840 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5841 	SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5842 	SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5843 	SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5844 	SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5845 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5846 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5847 	{}
5848 };
5849 
5850 static struct alc_config_preset alc260_presets[] = {
5851 	[ALC260_BASIC] = {
5852 		.mixers = { alc260_base_output_mixer,
5853 			    alc260_input_mixer },
5854 		.init_verbs = { alc260_init_verbs },
5855 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5856 		.dac_nids = alc260_dac_nids,
5857 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5858 		.adc_nids = alc260_adc_nids,
5859 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5860 		.channel_mode = alc260_modes,
5861 		.input_mux = &alc260_capture_source,
5862 	},
5863 	[ALC260_HP] = {
5864 		.mixers = { alc260_hp_output_mixer,
5865 			    alc260_input_mixer },
5866 		.init_verbs = { alc260_init_verbs,
5867 				alc260_hp_unsol_verbs },
5868 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5869 		.dac_nids = alc260_dac_nids,
5870 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5871 		.adc_nids = alc260_adc_nids_alt,
5872 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5873 		.channel_mode = alc260_modes,
5874 		.input_mux = &alc260_capture_source,
5875 		.unsol_event = alc260_hp_unsol_event,
5876 		.init_hook = alc260_hp_automute,
5877 	},
5878 	[ALC260_HP_DC7600] = {
5879 		.mixers = { alc260_hp_dc7600_mixer,
5880 			    alc260_input_mixer },
5881 		.init_verbs = { alc260_init_verbs,
5882 				alc260_hp_dc7600_verbs },
5883 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5884 		.dac_nids = alc260_dac_nids,
5885 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5886 		.adc_nids = alc260_adc_nids_alt,
5887 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5888 		.channel_mode = alc260_modes,
5889 		.input_mux = &alc260_capture_source,
5890 		.unsol_event = alc260_hp_3012_unsol_event,
5891 		.init_hook = alc260_hp_3012_automute,
5892 	},
5893 	[ALC260_HP_3013] = {
5894 		.mixers = { alc260_hp_3013_mixer,
5895 			    alc260_input_mixer },
5896 		.init_verbs = { alc260_hp_3013_init_verbs,
5897 				alc260_hp_3013_unsol_verbs },
5898 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5899 		.dac_nids = alc260_dac_nids,
5900 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5901 		.adc_nids = alc260_adc_nids_alt,
5902 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5903 		.channel_mode = alc260_modes,
5904 		.input_mux = &alc260_capture_source,
5905 		.unsol_event = alc260_hp_3013_unsol_event,
5906 		.init_hook = alc260_hp_3013_automute,
5907 	},
5908 	[ALC260_FUJITSU_S702X] = {
5909 		.mixers = { alc260_fujitsu_mixer },
5910 		.init_verbs = { alc260_fujitsu_init_verbs },
5911 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5912 		.dac_nids = alc260_dac_nids,
5913 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5914 		.adc_nids = alc260_dual_adc_nids,
5915 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5916 		.channel_mode = alc260_modes,
5917 		.num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5918 		.input_mux = alc260_fujitsu_capture_sources,
5919 	},
5920 	[ALC260_ACER] = {
5921 		.mixers = { alc260_acer_mixer },
5922 		.init_verbs = { alc260_acer_init_verbs },
5923 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5924 		.dac_nids = alc260_dac_nids,
5925 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5926 		.adc_nids = alc260_dual_adc_nids,
5927 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5928 		.channel_mode = alc260_modes,
5929 		.num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5930 		.input_mux = alc260_acer_capture_sources,
5931 	},
5932 	[ALC260_FAVORIT100] = {
5933 		.mixers = { alc260_favorit100_mixer },
5934 		.init_verbs = { alc260_favorit100_init_verbs },
5935 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5936 		.dac_nids = alc260_dac_nids,
5937 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5938 		.adc_nids = alc260_dual_adc_nids,
5939 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5940 		.channel_mode = alc260_modes,
5941 		.num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
5942 		.input_mux = alc260_favorit100_capture_sources,
5943 	},
5944 	[ALC260_WILL] = {
5945 		.mixers = { alc260_will_mixer },
5946 		.init_verbs = { alc260_init_verbs, alc260_will_verbs },
5947 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5948 		.dac_nids = alc260_dac_nids,
5949 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5950 		.adc_nids = alc260_adc_nids,
5951 		.dig_out_nid = ALC260_DIGOUT_NID,
5952 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5953 		.channel_mode = alc260_modes,
5954 		.input_mux = &alc260_capture_source,
5955 	},
5956 	[ALC260_REPLACER_672V] = {
5957 		.mixers = { alc260_replacer_672v_mixer },
5958 		.init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5959 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
5960 		.dac_nids = alc260_dac_nids,
5961 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5962 		.adc_nids = alc260_adc_nids,
5963 		.dig_out_nid = ALC260_DIGOUT_NID,
5964 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5965 		.channel_mode = alc260_modes,
5966 		.input_mux = &alc260_capture_source,
5967 		.unsol_event = alc260_replacer_672v_unsol_event,
5968 		.init_hook = alc260_replacer_672v_automute,
5969 	},
5970 #ifdef CONFIG_SND_DEBUG
5971 	[ALC260_TEST] = {
5972 		.mixers = { alc260_test_mixer },
5973 		.init_verbs = { alc260_test_init_verbs },
5974 		.num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5975 		.dac_nids = alc260_test_dac_nids,
5976 		.num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5977 		.adc_nids = alc260_test_adc_nids,
5978 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
5979 		.channel_mode = alc260_modes,
5980 		.num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5981 		.input_mux = alc260_test_capture_sources,
5982 	},
5983 #endif
5984 };
5985 
5986 static int patch_alc260(struct hda_codec *codec)
5987 {
5988 	struct alc_spec *spec;
5989 	int err, board_config;
5990 
5991 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5992 	if (spec == NULL)
5993 		return -ENOMEM;
5994 
5995 	codec->spec = spec;
5996 
5997 	board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5998 						  alc260_models,
5999 						  alc260_cfg_tbl);
6000 	if (board_config < 0) {
6001 		snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
6002 			   "trying auto-probe from BIOS...\n");
6003 		board_config = ALC260_AUTO;
6004 	}
6005 
6006 	if (board_config == ALC260_AUTO) {
6007 		/* automatic parse from the BIOS config */
6008 		err = alc260_parse_auto_config(codec);
6009 		if (err < 0) {
6010 			alc_free(codec);
6011 			return err;
6012 		} else if (!err) {
6013 			printk(KERN_INFO
6014 			       "hda_codec: Cannot set up configuration "
6015 			       "from BIOS.  Using base mode...\n");
6016 			board_config = ALC260_BASIC;
6017 		}
6018 	}
6019 
6020 	err = snd_hda_attach_beep_device(codec, 0x1);
6021 	if (err < 0) {
6022 		alc_free(codec);
6023 		return err;
6024 	}
6025 
6026 	if (board_config != ALC260_AUTO)
6027 		setup_preset(spec, &alc260_presets[board_config]);
6028 
6029 	spec->stream_name_analog = "ALC260 Analog";
6030 	spec->stream_analog_playback = &alc260_pcm_analog_playback;
6031 	spec->stream_analog_capture = &alc260_pcm_analog_capture;
6032 
6033 	spec->stream_name_digital = "ALC260 Digital";
6034 	spec->stream_digital_playback = &alc260_pcm_digital_playback;
6035 	spec->stream_digital_capture = &alc260_pcm_digital_capture;
6036 
6037 	if (!spec->adc_nids && spec->input_mux) {
6038 		/* check whether NID 0x04 is valid */
6039 		unsigned int wcap = get_wcaps(codec, 0x04);
6040 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6041 		/* get type */
6042 		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6043 			spec->adc_nids = alc260_adc_nids_alt;
6044 			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6045 		} else {
6046 			spec->adc_nids = alc260_adc_nids;
6047 			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6048 		}
6049 	}
6050 	set_capture_mixer(spec);
6051 	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6052 
6053 	spec->vmaster_nid = 0x08;
6054 
6055 	codec->patch_ops = alc_patch_ops;
6056 	if (board_config == ALC260_AUTO)
6057 		spec->init_hook = alc260_auto_init;
6058 #ifdef CONFIG_SND_HDA_POWER_SAVE
6059 	if (!spec->loopback.amplist)
6060 		spec->loopback.amplist = alc260_loopbacks;
6061 #endif
6062 	codec->proc_widget_hook = print_realtek_coef;
6063 
6064 	return 0;
6065 }
6066 
6067 
6068 /*
6069  * ALC882 support
6070  *
6071  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6072  * configuration.  Each pin widget can choose any input DACs and a mixer.
6073  * Each ADC is connected from a mixer of all inputs.  This makes possible
6074  * 6-channel independent captures.
6075  *
6076  * In addition, an independent DAC for the multi-playback (not used in this
6077  * driver yet).
6078  */
6079 #define ALC882_DIGOUT_NID	0x06
6080 #define ALC882_DIGIN_NID	0x0a
6081 
6082 static struct hda_channel_mode alc882_ch_modes[1] = {
6083 	{ 8, NULL }
6084 };
6085 
6086 static hda_nid_t alc882_dac_nids[4] = {
6087 	/* front, rear, clfe, rear_surr */
6088 	0x02, 0x03, 0x04, 0x05
6089 };
6090 
6091 /* identical with ALC880 */
6092 #define alc882_adc_nids		alc880_adc_nids
6093 #define alc882_adc_nids_alt	alc880_adc_nids_alt
6094 
6095 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6096 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6097 
6098 /* input MUX */
6099 /* FIXME: should be a matrix-type input source selection */
6100 
6101 static struct hda_input_mux alc882_capture_source = {
6102 	.num_items = 4,
6103 	.items = {
6104 		{ "Mic", 0x0 },
6105 		{ "Front Mic", 0x1 },
6106 		{ "Line", 0x2 },
6107 		{ "CD", 0x4 },
6108 	},
6109 };
6110 /*
6111  * 2ch mode
6112  */
6113 static struct hda_verb alc882_3ST_ch2_init[] = {
6114 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6115 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6116 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6117 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6118 	{ } /* end */
6119 };
6120 
6121 /*
6122  * 6ch mode
6123  */
6124 static struct hda_verb alc882_3ST_ch6_init[] = {
6125 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6126 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6127 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6128 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6129 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6130 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6131 	{ } /* end */
6132 };
6133 
6134 static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
6135 	{ 2, alc882_3ST_ch2_init },
6136 	{ 6, alc882_3ST_ch6_init },
6137 };
6138 
6139 /*
6140  * 6ch mode
6141  */
6142 static struct hda_verb alc882_sixstack_ch6_init[] = {
6143 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6144 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6145 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6146 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6147 	{ } /* end */
6148 };
6149 
6150 /*
6151  * 8ch mode
6152  */
6153 static struct hda_verb alc882_sixstack_ch8_init[] = {
6154 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6155 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6156 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6157 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6158 	{ } /* end */
6159 };
6160 
6161 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6162 	{ 6, alc882_sixstack_ch6_init },
6163 	{ 8, alc882_sixstack_ch8_init },
6164 };
6165 
6166 /*
6167  * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
6168  */
6169 
6170 /*
6171  * 2ch mode
6172  */
6173 static struct hda_verb alc885_mbp_ch2_init[] = {
6174 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6175 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6176 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6177 	{ } /* end */
6178 };
6179 
6180 /*
6181  * 6ch mode
6182  */
6183 static struct hda_verb alc885_mbp_ch6_init[] = {
6184 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6185 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6186 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6187 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6188 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6189 	{ } /* end */
6190 };
6191 
6192 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6193 	{ 2, alc885_mbp_ch2_init },
6194 	{ 6, alc885_mbp_ch6_init },
6195 };
6196 
6197 
6198 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6199  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6200  */
6201 static struct snd_kcontrol_new alc882_base_mixer[] = {
6202 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6203 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6204 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6205 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6206 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6207 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6208 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6209 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6210 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6211 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6212 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6213 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6214 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6215 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6216 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6217 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6218 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6219 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6220 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6221 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6222 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6223 	{ } /* end */
6224 };
6225 
6226 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6227 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6228 	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6229 	HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6230 	HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6231 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6232 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6233 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6234 	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6235 	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6236 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6237 	{ } /* end */
6238 };
6239 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6240 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6241 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6242 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6243 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6244 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6245 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6246 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6247 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6248 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6249 	{ } /* end */
6250 };
6251 
6252 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6253 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6254 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6255 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6256 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6257 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6258 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6259 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6260 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6261 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6262 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6263 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6264 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6265 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6266 	{ } /* end */
6267 };
6268 
6269 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6270  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6271  */
6272 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6273 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6274 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6275 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6276 	HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6277 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6278 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6279 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6280 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6281 	HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6282 	HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6283 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6284 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6285 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6286 	{ } /* end */
6287 };
6288 
6289 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6290 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6291 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6292 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6293 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6294 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6295 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6296 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6297 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6298 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6299 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6300 	{ } /* end */
6301 };
6302 
6303 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6304 	{
6305 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6306 		.name = "Channel Mode",
6307 		.info = alc_ch_mode_info,
6308 		.get = alc_ch_mode_get,
6309 		.put = alc_ch_mode_put,
6310 	},
6311 	{ } /* end */
6312 };
6313 
6314 static struct hda_verb alc882_init_verbs[] = {
6315 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
6316 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6317 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6318 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6319 	/* Rear mixer */
6320 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6321 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6322 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6323 	/* CLFE mixer */
6324 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6325 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6326 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6327 	/* Side mixer */
6328 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6329 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6330 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6331 
6332 	/* Front Pin: output 0 (0x0c) */
6333 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6334 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6335 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6336 	/* Rear Pin: output 1 (0x0d) */
6337 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6338 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6339 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6340 	/* CLFE Pin: output 2 (0x0e) */
6341 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6342 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6343 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6344 	/* Side Pin: output 3 (0x0f) */
6345 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6346 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6347 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6348 	/* Mic (rear) pin: input vref at 80% */
6349 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6350 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6351 	/* Front Mic pin: input vref at 80% */
6352 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6353 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6354 	/* Line In pin: input */
6355 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6356 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6357 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
6358 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6359 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6360 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6361 	/* CD pin widget for input */
6362 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6363 
6364 	/* FIXME: use matrix-type input source selection */
6365 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6366 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6367 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6368 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6369 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6370 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6371 	/* Input mixer2 */
6372 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6373 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6374 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6375 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6376 	/* Input mixer3 */
6377 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6378 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6379 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6380 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6381 	/* ADC1: mute amp left and right */
6382 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6383 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6384 	/* ADC2: mute amp left and right */
6385 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6386 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6387 	/* ADC3: mute amp left and right */
6388 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6389 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6390 
6391 	{ }
6392 };
6393 
6394 static struct hda_verb alc882_eapd_verbs[] = {
6395 	/* change to EAPD mode */
6396 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6397 	{0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6398 	{ }
6399 };
6400 
6401 /* Mac Pro test */
6402 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6403 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6404 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6405 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6406 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6407 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6408 	/* FIXME: this looks suspicious...
6409 	HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6410 	HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6411 	*/
6412 	{ } /* end */
6413 };
6414 
6415 static struct hda_verb alc882_macpro_init_verbs[] = {
6416 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
6417 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6418 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6419 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6420 	/* Front Pin: output 0 (0x0c) */
6421 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6422 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6423 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6424 	/* Front Mic pin: input vref at 80% */
6425 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6426 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6427 	/* Speaker:  output */
6428 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6429 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6430 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6431 	/* Headphone output (output 0 - 0x0c) */
6432 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6433 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6434 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6435 
6436 	/* FIXME: use matrix-type input source selection */
6437 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6438 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6439 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6440 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6441 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6442 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6443 	/* Input mixer2 */
6444 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6445 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6446 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6447 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6448 	/* Input mixer3 */
6449 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6450 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6451 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6452 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6453 	/* ADC1: mute amp left and right */
6454 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6455 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6456 	/* ADC2: mute amp left and right */
6457 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6458 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6459 	/* ADC3: mute amp left and right */
6460 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6461 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6462 
6463 	{ }
6464 };
6465 
6466 /* Macbook Pro rev3 */
6467 static struct hda_verb alc885_mbp3_init_verbs[] = {
6468 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
6469 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6470 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6471 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6472 	/* Rear mixer */
6473 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6474 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6475 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6476 	/* Front Pin: output 0 (0x0c) */
6477 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6478 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6479 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6480 	/* HP Pin: output 0 (0x0d) */
6481 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
6482 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6483 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6484 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6485 	/* Mic (rear) pin: input vref at 80% */
6486 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6487 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6488 	/* Front Mic pin: input vref at 80% */
6489 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6490 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6491 	/* Line In pin: use output 1 when in LineOut mode */
6492 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6493 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6494 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
6495 
6496 	/* FIXME: use matrix-type input source selection */
6497 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6498 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6499 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6500 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6501 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6502 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6503 	/* Input mixer2 */
6504 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6505 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6506 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6507 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6508 	/* Input mixer3 */
6509 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6510 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6511 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6512 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6513 	/* ADC1: mute amp left and right */
6514 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6515 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6516 	/* ADC2: mute amp left and right */
6517 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6518 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6519 	/* ADC3: mute amp left and right */
6520 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6521 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6522 
6523 	{ }
6524 };
6525 
6526 /* iMac 24 mixer. */
6527 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
6528 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6529 	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
6530 	{ } /* end */
6531 };
6532 
6533 /* iMac 24 init verbs. */
6534 static struct hda_verb alc885_imac24_init_verbs[] = {
6535 	/* Internal speakers: output 0 (0x0c) */
6536 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6537 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6538 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6539 	/* Internal speakers: output 0 (0x0c) */
6540 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6541 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6542 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
6543 	/* Headphone: output 0 (0x0c) */
6544 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6545 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6546 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6547 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6548 	/* Front Mic: input vref at 80% */
6549 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6550 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6551 	{ }
6552 };
6553 
6554 /* Toggle speaker-output according to the hp-jack state */
6555 static void alc885_imac24_automute(struct hda_codec *codec)
6556 {
6557  	unsigned int present;
6558 
6559  	present = snd_hda_codec_read(codec, 0x14, 0,
6560 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6561 	snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
6562 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6563 	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
6564 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6565 }
6566 
6567 /* Processes unsolicited events. */
6568 static void alc885_imac24_unsol_event(struct hda_codec *codec,
6569 				      unsigned int res)
6570 {
6571 	/* Headphone insertion or removal. */
6572 	if ((res >> 26) == ALC880_HP_EVENT)
6573 		alc885_imac24_automute(codec);
6574 }
6575 
6576 static void alc885_mbp3_automute(struct hda_codec *codec)
6577 {
6578  	unsigned int present;
6579 
6580  	present = snd_hda_codec_read(codec, 0x15, 0,
6581 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6582 	snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
6583 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6584 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
6585 				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
6586 
6587 }
6588 static void alc885_mbp3_unsol_event(struct hda_codec *codec,
6589 				    unsigned int res)
6590 {
6591 	/* Headphone insertion or removal. */
6592 	if ((res >> 26) == ALC880_HP_EVENT)
6593 		alc885_mbp3_automute(codec);
6594 }
6595 
6596 
6597 static struct hda_verb alc882_targa_verbs[] = {
6598 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6599 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6600 
6601 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6602 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6603 
6604 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6605 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6606 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6607 
6608 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
6609 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
6610 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
6611 	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
6612 	{ } /* end */
6613 };
6614 
6615 /* toggle speaker-output according to the hp-jack state */
6616 static void alc882_targa_automute(struct hda_codec *codec)
6617 {
6618  	unsigned int present;
6619 
6620  	present = snd_hda_codec_read(codec, 0x14, 0,
6621 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
6622 	snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
6623 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
6624 	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
6625 				  present ? 1 : 3);
6626 }
6627 
6628 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
6629 {
6630 	/* Looks like the unsol event is incompatible with the standard
6631 	 * definition.  4bit tag is placed at 26 bit!
6632 	 */
6633 	if (((res >> 26) == ALC880_HP_EVENT)) {
6634 		alc882_targa_automute(codec);
6635 	}
6636 }
6637 
6638 static struct hda_verb alc882_asus_a7j_verbs[] = {
6639 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6640 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6641 
6642 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6643 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6644 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6645 
6646 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6647 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6648 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6649 
6650 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6651 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6652 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6653 	{ } /* end */
6654 };
6655 
6656 static struct hda_verb alc882_asus_a7m_verbs[] = {
6657 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6658 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6659 
6660 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6661 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6662 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6663 
6664 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6665 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6666 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
6667 
6668 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
6669 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
6670 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
6671  	{ } /* end */
6672 };
6673 
6674 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
6675 {
6676 	unsigned int gpiostate, gpiomask, gpiodir;
6677 
6678 	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
6679 				       AC_VERB_GET_GPIO_DATA, 0);
6680 
6681 	if (!muted)
6682 		gpiostate |= (1 << pin);
6683 	else
6684 		gpiostate &= ~(1 << pin);
6685 
6686 	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
6687 				      AC_VERB_GET_GPIO_MASK, 0);
6688 	gpiomask |= (1 << pin);
6689 
6690 	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
6691 				     AC_VERB_GET_GPIO_DIRECTION, 0);
6692 	gpiodir |= (1 << pin);
6693 
6694 
6695 	snd_hda_codec_write(codec, codec->afg, 0,
6696 			    AC_VERB_SET_GPIO_MASK, gpiomask);
6697 	snd_hda_codec_write(codec, codec->afg, 0,
6698 			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
6699 
6700 	msleep(1);
6701 
6702 	snd_hda_codec_write(codec, codec->afg, 0,
6703 			    AC_VERB_SET_GPIO_DATA, gpiostate);
6704 }
6705 
6706 /* set up GPIO at initialization */
6707 static void alc885_macpro_init_hook(struct hda_codec *codec)
6708 {
6709 	alc882_gpio_mute(codec, 0, 0);
6710 	alc882_gpio_mute(codec, 1, 0);
6711 }
6712 
6713 /* set up GPIO and update auto-muting at initialization */
6714 static void alc885_imac24_init_hook(struct hda_codec *codec)
6715 {
6716 	alc885_macpro_init_hook(codec);
6717 	alc885_imac24_automute(codec);
6718 }
6719 
6720 /*
6721  * generic initialization of ADC, input mixers and output mixers
6722  */
6723 static struct hda_verb alc882_auto_init_verbs[] = {
6724 	/*
6725 	 * Unmute ADC0-2 and set the default input to mic-in
6726 	 */
6727 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6728 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6729 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6730 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6731 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6732 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6733 
6734 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6735 	 * mixer widget
6736 	 * Note: PASD motherboards uses the Line In 2 as the input for
6737 	 * front panel mic (mic 2)
6738 	 */
6739 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6740 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6741 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6742 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6743 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6744 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6745 
6746 	/*
6747 	 * Set up output mixers (0x0c - 0x0f)
6748 	 */
6749 	/* set vol=0 to output mixers */
6750 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6751 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6752 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6753 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6754 	/* set up input amps for analog loopback */
6755 	/* Amp Indices: DAC = 0, mixer = 1 */
6756 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6757 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6758 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6759 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6760 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6761 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6762 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6763 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6764 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6765 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6766 
6767 	/* FIXME: use matrix-type input source selection */
6768 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6769 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6770 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6771 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6772 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6773 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6774 	/* Input mixer2 */
6775 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6776 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6777 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6778 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6779 	/* Input mixer3 */
6780 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6781 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
6782 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
6783 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
6784 
6785 	{ }
6786 };
6787 
6788 #ifdef CONFIG_SND_HDA_POWER_SAVE
6789 #define alc882_loopbacks	alc880_loopbacks
6790 #endif
6791 
6792 /* pcm configuration: identiacal with ALC880 */
6793 #define alc882_pcm_analog_playback	alc880_pcm_analog_playback
6794 #define alc882_pcm_analog_capture	alc880_pcm_analog_capture
6795 #define alc882_pcm_digital_playback	alc880_pcm_digital_playback
6796 #define alc882_pcm_digital_capture	alc880_pcm_digital_capture
6797 
6798 /*
6799  * configuration and preset
6800  */
6801 static const char *alc882_models[ALC882_MODEL_LAST] = {
6802 	[ALC882_3ST_DIG]	= "3stack-dig",
6803 	[ALC882_6ST_DIG]	= "6stack-dig",
6804 	[ALC882_ARIMA]		= "arima",
6805 	[ALC882_W2JC]		= "w2jc",
6806 	[ALC882_TARGA]		= "targa",
6807 	[ALC882_ASUS_A7J]	= "asus-a7j",
6808 	[ALC882_ASUS_A7M]	= "asus-a7m",
6809 	[ALC885_MACPRO]		= "macpro",
6810 	[ALC885_MBP3]		= "mbp3",
6811 	[ALC885_IMAC24]		= "imac24",
6812 	[ALC882_AUTO]		= "auto",
6813 };
6814 
6815 static struct snd_pci_quirk alc882_cfg_tbl[] = {
6816 	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
6817 	SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
6818 	SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
6819 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
6820 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
6821 	SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
6822 	SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
6823 	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
6824 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
6825 	SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
6826 	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
6827 	SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
6828 	{}
6829 };
6830 
6831 static struct alc_config_preset alc882_presets[] = {
6832 	[ALC882_3ST_DIG] = {
6833 		.mixers = { alc882_base_mixer },
6834 		.init_verbs = { alc882_init_verbs },
6835 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6836 		.dac_nids = alc882_dac_nids,
6837 		.dig_out_nid = ALC882_DIGOUT_NID,
6838 		.dig_in_nid = ALC882_DIGIN_NID,
6839 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6840 		.channel_mode = alc882_ch_modes,
6841 		.need_dac_fix = 1,
6842 		.input_mux = &alc882_capture_source,
6843 	},
6844 	[ALC882_6ST_DIG] = {
6845 		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
6846 		.init_verbs = { alc882_init_verbs },
6847 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6848 		.dac_nids = alc882_dac_nids,
6849 		.dig_out_nid = ALC882_DIGOUT_NID,
6850 		.dig_in_nid = ALC882_DIGIN_NID,
6851 		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6852 		.channel_mode = alc882_sixstack_modes,
6853 		.input_mux = &alc882_capture_source,
6854 	},
6855 	[ALC882_ARIMA] = {
6856 		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
6857 		.init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
6858 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6859 		.dac_nids = alc882_dac_nids,
6860 		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
6861 		.channel_mode = alc882_sixstack_modes,
6862 		.input_mux = &alc882_capture_source,
6863 	},
6864 	[ALC882_W2JC] = {
6865 		.mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
6866 		.init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6867 				alc880_gpio1_init_verbs },
6868 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6869 		.dac_nids = alc882_dac_nids,
6870 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6871 		.channel_mode = alc880_threestack_modes,
6872 		.need_dac_fix = 1,
6873 		.input_mux = &alc882_capture_source,
6874 		.dig_out_nid = ALC882_DIGOUT_NID,
6875 	},
6876 	[ALC885_MBP3] = {
6877 		.mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
6878 		.init_verbs = { alc885_mbp3_init_verbs,
6879 				alc880_gpio1_init_verbs },
6880 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6881 		.dac_nids = alc882_dac_nids,
6882 		.channel_mode = alc885_mbp_6ch_modes,
6883 		.num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
6884 		.input_mux = &alc882_capture_source,
6885 		.dig_out_nid = ALC882_DIGOUT_NID,
6886 		.dig_in_nid = ALC882_DIGIN_NID,
6887 		.unsol_event = alc885_mbp3_unsol_event,
6888 		.init_hook = alc885_mbp3_automute,
6889 	},
6890 	[ALC885_MACPRO] = {
6891 		.mixers = { alc882_macpro_mixer },
6892 		.init_verbs = { alc882_macpro_init_verbs },
6893 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6894 		.dac_nids = alc882_dac_nids,
6895 		.dig_out_nid = ALC882_DIGOUT_NID,
6896 		.dig_in_nid = ALC882_DIGIN_NID,
6897 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6898 		.channel_mode = alc882_ch_modes,
6899 		.input_mux = &alc882_capture_source,
6900 		.init_hook = alc885_macpro_init_hook,
6901 	},
6902 	[ALC885_IMAC24] = {
6903 		.mixers = { alc885_imac24_mixer },
6904 		.init_verbs = { alc885_imac24_init_verbs },
6905 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6906 		.dac_nids = alc882_dac_nids,
6907 		.dig_out_nid = ALC882_DIGOUT_NID,
6908 		.dig_in_nid = ALC882_DIGIN_NID,
6909 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
6910 		.channel_mode = alc882_ch_modes,
6911 		.input_mux = &alc882_capture_source,
6912 		.unsol_event = alc885_imac24_unsol_event,
6913 		.init_hook = alc885_imac24_init_hook,
6914 	},
6915 	[ALC882_TARGA] = {
6916 		.mixers = { alc882_targa_mixer, alc882_chmode_mixer },
6917 		.init_verbs = { alc882_init_verbs, alc882_targa_verbs},
6918 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6919 		.dac_nids = alc882_dac_nids,
6920 		.dig_out_nid = ALC882_DIGOUT_NID,
6921 		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6922 		.adc_nids = alc882_adc_nids,
6923 		.capsrc_nids = alc882_capsrc_nids,
6924 		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6925 		.channel_mode = alc882_3ST_6ch_modes,
6926 		.need_dac_fix = 1,
6927 		.input_mux = &alc882_capture_source,
6928 		.unsol_event = alc882_targa_unsol_event,
6929 		.init_hook = alc882_targa_automute,
6930 	},
6931 	[ALC882_ASUS_A7J] = {
6932 		.mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
6933 		.init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
6934 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6935 		.dac_nids = alc882_dac_nids,
6936 		.dig_out_nid = ALC882_DIGOUT_NID,
6937 		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
6938 		.adc_nids = alc882_adc_nids,
6939 		.capsrc_nids = alc882_capsrc_nids,
6940 		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
6941 		.channel_mode = alc882_3ST_6ch_modes,
6942 		.need_dac_fix = 1,
6943 		.input_mux = &alc882_capture_source,
6944 	},
6945 	[ALC882_ASUS_A7M] = {
6946 		.mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
6947 		.init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
6948 				alc880_gpio1_init_verbs,
6949 				alc882_asus_a7m_verbs },
6950 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
6951 		.dac_nids = alc882_dac_nids,
6952 		.dig_out_nid = ALC882_DIGOUT_NID,
6953 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
6954 		.channel_mode = alc880_threestack_modes,
6955 		.need_dac_fix = 1,
6956 		.input_mux = &alc882_capture_source,
6957 	},
6958 };
6959 
6960 
6961 /*
6962  * Pin config fixes
6963  */
6964 enum {
6965 	PINFIX_ABIT_AW9D_MAX
6966 };
6967 
6968 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
6969 	{ 0x15, 0x01080104 }, /* side */
6970 	{ 0x16, 0x01011012 }, /* rear */
6971 	{ 0x17, 0x01016011 }, /* clfe */
6972 	{ }
6973 };
6974 
6975 static const struct alc_pincfg *alc882_pin_fixes[] = {
6976 	[PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
6977 };
6978 
6979 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
6980 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
6981 	{}
6982 };
6983 
6984 /*
6985  * BIOS auto configuration
6986  */
6987 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
6988 					      hda_nid_t nid, int pin_type,
6989 					      int dac_idx)
6990 {
6991 	/* set as output */
6992 	struct alc_spec *spec = codec->spec;
6993 	int idx;
6994 
6995 	alc_set_pin_output(codec, nid, pin_type);
6996 	if (spec->multiout.dac_nids[dac_idx] == 0x25)
6997 		idx = 4;
6998 	else
6999 		idx = spec->multiout.dac_nids[dac_idx] - 2;
7000 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
7001 
7002 }
7003 
7004 static void alc882_auto_init_multi_out(struct hda_codec *codec)
7005 {
7006 	struct alc_spec *spec = codec->spec;
7007 	int i;
7008 
7009 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
7010 	for (i = 0; i <= HDA_SIDE; i++) {
7011 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
7012 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
7013 		if (nid)
7014 			alc882_auto_set_output_and_unmute(codec, nid, pin_type,
7015 							  i);
7016 	}
7017 }
7018 
7019 static void alc882_auto_init_hp_out(struct hda_codec *codec)
7020 {
7021 	struct alc_spec *spec = codec->spec;
7022 	hda_nid_t pin;
7023 
7024 	pin = spec->autocfg.hp_pins[0];
7025 	if (pin) /* connect to front */
7026 		/* use dac 0 */
7027 		alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
7028 	pin = spec->autocfg.speaker_pins[0];
7029 	if (pin)
7030 		alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
7031 }
7032 
7033 #define alc882_is_input_pin(nid)	alc880_is_input_pin(nid)
7034 #define ALC882_PIN_CD_NID		ALC880_PIN_CD_NID
7035 
7036 static void alc882_auto_init_analog_input(struct hda_codec *codec)
7037 {
7038 	struct alc_spec *spec = codec->spec;
7039 	int i;
7040 
7041 	for (i = 0; i < AUTO_PIN_LAST; i++) {
7042 		hda_nid_t nid = spec->autocfg.input_pins[i];
7043 		if (!nid)
7044 			continue;
7045 		alc_set_input_pin(codec, nid, AUTO_PIN_FRONT_MIC /*i*/);
7046 		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
7047 			snd_hda_codec_write(codec, nid, 0,
7048 					    AC_VERB_SET_AMP_GAIN_MUTE,
7049 					    AMP_OUT_MUTE);
7050 	}
7051 }
7052 
7053 static void alc882_auto_init_input_src(struct hda_codec *codec)
7054 {
7055 	struct alc_spec *spec = codec->spec;
7056 	int c;
7057 
7058 	for (c = 0; c < spec->num_adc_nids; c++) {
7059 		hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
7060 		hda_nid_t nid = spec->capsrc_nids[c];
7061 		unsigned int mux_idx;
7062 		const struct hda_input_mux *imux;
7063 		int conns, mute, idx, item;
7064 
7065 		conns = snd_hda_get_connections(codec, nid, conn_list,
7066 						ARRAY_SIZE(conn_list));
7067 		if (conns < 0)
7068 			continue;
7069 		mux_idx = c >= spec->num_mux_defs ? 0 : c;
7070 		imux = &spec->input_mux[mux_idx];
7071 		for (idx = 0; idx < conns; idx++) {
7072 			/* if the current connection is the selected one,
7073 			 * unmute it as default - otherwise mute it
7074 			 */
7075 			mute = AMP_IN_MUTE(idx);
7076 			for (item = 0; item < imux->num_items; item++) {
7077 				if (imux->items[item].index == idx) {
7078 					if (spec->cur_mux[c] == item)
7079 						mute = AMP_IN_UNMUTE(idx);
7080 					break;
7081 				}
7082 			}
7083 			/* check if we have a selector or mixer
7084 			 * we could check for the widget type instead, but
7085 			 * just check for Amp-In presence (in case of mixer
7086 			 * without amp-in there is something wrong, this
7087 			 * function shouldn't be used or capsrc nid is wrong)
7088 			 */
7089 			if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
7090 				snd_hda_codec_write(codec, nid, 0,
7091 						    AC_VERB_SET_AMP_GAIN_MUTE,
7092 						    mute);
7093 			else if (mute != AMP_IN_MUTE(idx))
7094 				snd_hda_codec_write(codec, nid, 0,
7095 						    AC_VERB_SET_CONNECT_SEL,
7096 						    idx);
7097 		}
7098 	}
7099 }
7100 
7101 /* add mic boosts if needed */
7102 static int alc_auto_add_mic_boost(struct hda_codec *codec)
7103 {
7104 	struct alc_spec *spec = codec->spec;
7105 	int err;
7106 	hda_nid_t nid;
7107 
7108 	nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
7109 	if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7110 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
7111 				  "Mic Boost",
7112 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7113 		if (err < 0)
7114 			return err;
7115 	}
7116 	nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
7117 	if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
7118 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
7119 				  "Front Mic Boost",
7120 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
7121 		if (err < 0)
7122 			return err;
7123 	}
7124 	return 0;
7125 }
7126 
7127 /* almost identical with ALC880 parser... */
7128 static int alc882_parse_auto_config(struct hda_codec *codec)
7129 {
7130 	struct alc_spec *spec = codec->spec;
7131 	int err = alc880_parse_auto_config(codec);
7132 
7133 	if (err < 0)
7134 		return err;
7135 	else if (!err)
7136 		return 0; /* no config found */
7137 
7138 	err = alc_auto_add_mic_boost(codec);
7139 	if (err < 0)
7140 		return err;
7141 
7142 	/* hack - override the init verbs */
7143 	spec->init_verbs[0] = alc882_auto_init_verbs;
7144 
7145 	return 1; /* config found */
7146 }
7147 
7148 /* additional initialization for auto-configuration model */
7149 static void alc882_auto_init(struct hda_codec *codec)
7150 {
7151 	struct alc_spec *spec = codec->spec;
7152 	alc882_auto_init_multi_out(codec);
7153 	alc882_auto_init_hp_out(codec);
7154 	alc882_auto_init_analog_input(codec);
7155 	alc882_auto_init_input_src(codec);
7156 	if (spec->unsol_event)
7157 		alc_inithook(codec);
7158 }
7159 
7160 static int patch_alc883(struct hda_codec *codec); /* called in patch_alc882() */
7161 
7162 static int patch_alc882(struct hda_codec *codec)
7163 {
7164 	struct alc_spec *spec;
7165 	int err, board_config;
7166 
7167 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7168 	if (spec == NULL)
7169 		return -ENOMEM;
7170 
7171 	codec->spec = spec;
7172 
7173 	board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
7174 						  alc882_models,
7175 						  alc882_cfg_tbl);
7176 
7177 	if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
7178 		/* Pick up systems that don't supply PCI SSID */
7179 		switch (codec->subsystem_id) {
7180 		case 0x106b0c00: /* Mac Pro */
7181 			board_config = ALC885_MACPRO;
7182 			break;
7183 		case 0x106b1000: /* iMac 24 */
7184 		case 0x106b2800: /* AppleTV */
7185 		case 0x106b3e00: /* iMac 24 Aluminium */
7186 			board_config = ALC885_IMAC24;
7187 			break;
7188 		case 0x106b00a0: /* MacBookPro3,1 - Another revision */
7189 		case 0x106b00a1: /* Macbook (might be wrong - PCI SSID?) */
7190 		case 0x106b00a4: /* MacbookPro4,1 */
7191 		case 0x106b2c00: /* Macbook Pro rev3 */
7192 		case 0x106b3600: /* Macbook 3.1 */
7193 		case 0x106b3800: /* MacbookPro4,1 - latter revision */
7194 			board_config = ALC885_MBP3;
7195 			break;
7196 		default:
7197 			/* ALC889A is handled better as ALC888-compatible */
7198 			if (codec->revision_id == 0x100101 ||
7199 			    codec->revision_id == 0x100103) {
7200 				alc_free(codec);
7201 				return patch_alc883(codec);
7202 			}
7203 			printk(KERN_INFO "hda_codec: Unknown model for ALC882, "
7204 		       			 "trying auto-probe from BIOS...\n");
7205 			board_config = ALC882_AUTO;
7206 		}
7207 	}
7208 
7209 	alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
7210 
7211 	if (board_config == ALC882_AUTO) {
7212 		/* automatic parse from the BIOS config */
7213 		err = alc882_parse_auto_config(codec);
7214 		if (err < 0) {
7215 			alc_free(codec);
7216 			return err;
7217 		} else if (!err) {
7218 			printk(KERN_INFO
7219 			       "hda_codec: Cannot set up configuration "
7220 			       "from BIOS.  Using base mode...\n");
7221 			board_config = ALC882_3ST_DIG;
7222 		}
7223 	}
7224 
7225 	err = snd_hda_attach_beep_device(codec, 0x1);
7226 	if (err < 0) {
7227 		alc_free(codec);
7228 		return err;
7229 	}
7230 
7231 	if (board_config != ALC882_AUTO)
7232 		setup_preset(spec, &alc882_presets[board_config]);
7233 
7234 	if (codec->vendor_id == 0x10ec0885) {
7235 		spec->stream_name_analog = "ALC885 Analog";
7236 		spec->stream_name_digital = "ALC885 Digital";
7237 	} else {
7238 		spec->stream_name_analog = "ALC882 Analog";
7239 		spec->stream_name_digital = "ALC882 Digital";
7240 	}
7241 
7242 	spec->stream_analog_playback = &alc882_pcm_analog_playback;
7243 	spec->stream_analog_capture = &alc882_pcm_analog_capture;
7244 	/* FIXME: setup DAC5 */
7245 	/*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
7246 	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
7247 
7248 	spec->stream_digital_playback = &alc882_pcm_digital_playback;
7249 	spec->stream_digital_capture = &alc882_pcm_digital_capture;
7250 
7251 	spec->capture_style = CAPT_MIX; /* matrix-style capture */
7252 	if (!spec->adc_nids && spec->input_mux) {
7253 		/* check whether NID 0x07 is valid */
7254 		unsigned int wcap = get_wcaps(codec, 0x07);
7255 		/* get type */
7256 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
7257 		if (wcap != AC_WID_AUD_IN) {
7258 			spec->adc_nids = alc882_adc_nids_alt;
7259 			spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
7260 			spec->capsrc_nids = alc882_capsrc_nids_alt;
7261 		} else {
7262 			spec->adc_nids = alc882_adc_nids;
7263 			spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
7264 			spec->capsrc_nids = alc882_capsrc_nids;
7265 		}
7266 	}
7267 	set_capture_mixer(spec);
7268 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
7269 
7270 	spec->vmaster_nid = 0x0c;
7271 
7272 	codec->patch_ops = alc_patch_ops;
7273 	if (board_config == ALC882_AUTO)
7274 		spec->init_hook = alc882_auto_init;
7275 #ifdef CONFIG_SND_HDA_POWER_SAVE
7276 	if (!spec->loopback.amplist)
7277 		spec->loopback.amplist = alc882_loopbacks;
7278 #endif
7279 	codec->proc_widget_hook = print_realtek_coef;
7280 
7281 	return 0;
7282 }
7283 
7284 /*
7285  * ALC883 support
7286  *
7287  * ALC883 is almost identical with ALC880 but has cleaner and more flexible
7288  * configuration.  Each pin widget can choose any input DACs and a mixer.
7289  * Each ADC is connected from a mixer of all inputs.  This makes possible
7290  * 6-channel independent captures.
7291  *
7292  * In addition, an independent DAC for the multi-playback (not used in this
7293  * driver yet).
7294  */
7295 #define ALC883_DIGOUT_NID	0x06
7296 #define ALC883_DIGIN_NID	0x0a
7297 
7298 #define ALC1200_DIGOUT_NID	0x10
7299 
7300 static hda_nid_t alc883_dac_nids[4] = {
7301 	/* front, rear, clfe, rear_surr */
7302 	0x02, 0x03, 0x04, 0x05
7303 };
7304 
7305 static hda_nid_t alc883_adc_nids[2] = {
7306 	/* ADC1-2 */
7307 	0x08, 0x09,
7308 };
7309 
7310 static hda_nid_t alc883_adc_nids_alt[1] = {
7311 	/* ADC1 */
7312 	0x08,
7313 };
7314 
7315 static hda_nid_t alc883_adc_nids_rev[2] = {
7316 	/* ADC2-1 */
7317 	0x09, 0x08
7318 };
7319 
7320 #define alc889_adc_nids		alc880_adc_nids
7321 
7322 static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
7323 
7324 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7325 
7326 #define alc889_capsrc_nids	alc882_capsrc_nids
7327 
7328 /* input MUX */
7329 /* FIXME: should be a matrix-type input source selection */
7330 
7331 static struct hda_input_mux alc883_capture_source = {
7332 	.num_items = 4,
7333 	.items = {
7334 		{ "Mic", 0x0 },
7335 		{ "Front Mic", 0x1 },
7336 		{ "Line", 0x2 },
7337 		{ "CD", 0x4 },
7338 	},
7339 };
7340 
7341 static struct hda_input_mux alc883_3stack_6ch_intel = {
7342 	.num_items = 4,
7343 	.items = {
7344 		{ "Mic", 0x1 },
7345 		{ "Front Mic", 0x0 },
7346 		{ "Line", 0x2 },
7347 		{ "CD", 0x4 },
7348 	},
7349 };
7350 
7351 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7352 	.num_items = 2,
7353 	.items = {
7354 		{ "Mic", 0x1 },
7355 		{ "Line", 0x2 },
7356 	},
7357 };
7358 
7359 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7360 	.num_items = 4,
7361 	.items = {
7362 		{ "Mic", 0x0 },
7363 		{ "iMic", 0x1 },
7364 		{ "Line", 0x2 },
7365 		{ "CD", 0x4 },
7366 	},
7367 };
7368 
7369 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7370 	.num_items = 2,
7371 	.items = {
7372 		{ "Mic", 0x0 },
7373 		{ "Int Mic", 0x1 },
7374 	},
7375 };
7376 
7377 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7378 	.num_items = 3,
7379 	.items = {
7380 		{ "Mic", 0x0 },
7381 		{ "Front Mic", 0x1 },
7382 		{ "Line", 0x4 },
7383 	},
7384 };
7385 
7386 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7387 	.num_items = 2,
7388 	.items = {
7389 		{ "Mic", 0x0 },
7390 		{ "Line", 0x2 },
7391 	},
7392 };
7393 
7394 /*
7395  * 2ch mode
7396  */
7397 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7398 	{ 2, NULL }
7399 };
7400 
7401 /*
7402  * 2ch mode
7403  */
7404 static struct hda_verb alc883_3ST_ch2_init[] = {
7405 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7406 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7407 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7408 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7409 	{ } /* end */
7410 };
7411 
7412 /*
7413  * 4ch mode
7414  */
7415 static struct hda_verb alc883_3ST_ch4_init[] = {
7416 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7417 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7418 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7419 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7420 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7421 	{ } /* end */
7422 };
7423 
7424 /*
7425  * 6ch mode
7426  */
7427 static struct hda_verb alc883_3ST_ch6_init[] = {
7428 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7429 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7430 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7431 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7432 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7433 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7434 	{ } /* end */
7435 };
7436 
7437 static struct hda_channel_mode alc883_3ST_6ch_modes[3] = {
7438 	{ 2, alc883_3ST_ch2_init },
7439 	{ 4, alc883_3ST_ch4_init },
7440 	{ 6, alc883_3ST_ch6_init },
7441 };
7442 
7443 /*
7444  * 2ch mode
7445  */
7446 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7447 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7448 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7449 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7450 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7451 	{ } /* end */
7452 };
7453 
7454 /*
7455  * 4ch mode
7456  */
7457 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7458 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7459 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7460 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7461 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7462 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7463 	{ } /* end */
7464 };
7465 
7466 /*
7467  * 6ch mode
7468  */
7469 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7470 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7471 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7472 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7473 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7474 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7475 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7476 	{ } /* end */
7477 };
7478 
7479 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7480 	{ 2, alc883_3ST_ch2_intel_init },
7481 	{ 4, alc883_3ST_ch4_intel_init },
7482 	{ 6, alc883_3ST_ch6_intel_init },
7483 };
7484 
7485 /*
7486  * 6ch mode
7487  */
7488 static struct hda_verb alc883_sixstack_ch6_init[] = {
7489 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7490 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7491 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7492 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7493 	{ } /* end */
7494 };
7495 
7496 /*
7497  * 8ch mode
7498  */
7499 static struct hda_verb alc883_sixstack_ch8_init[] = {
7500 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7501 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7502 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7503 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7504 	{ } /* end */
7505 };
7506 
7507 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7508 	{ 6, alc883_sixstack_ch6_init },
7509 	{ 8, alc883_sixstack_ch8_init },
7510 };
7511 
7512 static struct hda_verb alc883_medion_eapd_verbs[] = {
7513         /* eanable EAPD on medion laptop */
7514 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7515 	{0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7516 	{ }
7517 };
7518 
7519 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7520  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7521  */
7522 
7523 static struct snd_kcontrol_new alc883_base_mixer[] = {
7524 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7525 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7526 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7527 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7528 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7529 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7530 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7531 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7532 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7533 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7534 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7535 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7536 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7537 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7538 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7539 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7540 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7541 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7542 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7543 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7544 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7545 	{ } /* end */
7546 };
7547 
7548 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7549 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7550 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7551 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7552 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7553 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7554 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7555 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7556 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7557 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7558 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7559 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7560 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7561 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7562 	{ } /* end */
7563 };
7564 
7565 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7566 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7567 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7568 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7569 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7570 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7571 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7572 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7573 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7574 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7575 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7576 	{ } /* end */
7577 };
7578 
7579 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7580 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7581 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7582 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7583 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7584 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7585 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7586 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7587 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7588 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7589 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7590 	{ } /* end */
7591 };
7592 
7593 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7594 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7595 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7596 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7597 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7598 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7599 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7600 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7601 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7602 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7603 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7604 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7605 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7606 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7607 	{ } /* end */
7608 };
7609 
7610 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7611 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7612 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7613 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7614 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7615 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7616 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7617 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7618 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7619 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7620 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7621 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7622 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7623 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7624 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7625 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7626 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7627 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7628 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7629 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7630 	{ } /* end */
7631 };
7632 
7633 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7634 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7635 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7636 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7637 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7638 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7639 			      HDA_OUTPUT),
7640 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7641 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7642 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7643 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7644 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7645 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7646 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7647 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7648 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7649 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7650 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7651 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7652 	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7653 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7654 	{ } /* end */
7655 };
7656 
7657 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7658 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7659 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7660 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7661 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7662 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7663 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7664 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7665 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7666 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7667 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7668 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7669 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7670 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7671 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7672 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7673 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7674 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7675 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7676 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7677 	{ } /* end */
7678 };
7679 
7680 static struct snd_kcontrol_new alc883_tagra_mixer[] = {
7681 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7682 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7683 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7684 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7685 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7686 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7687 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7688 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7689 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7690 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7691 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7692 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7693 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7694 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7695 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7696 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7697 	{ } /* end */
7698 };
7699 
7700 static struct snd_kcontrol_new alc883_tagra_2ch_mixer[] = {
7701 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7702 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7703 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7704 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7705 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7706 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7707 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7708 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7709 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7710 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7711 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7712 	{ } /* end */
7713 };
7714 
7715 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7716 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7717 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7718 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7719 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7720 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7721 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7722 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7723 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7724 	{ } /* end */
7725 };
7726 
7727 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7728 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7729 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7730 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7731 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7732 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7733 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7734 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7735 	HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7736 	HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7737 	{ } /* end */
7738 };
7739 
7740 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7741 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7742 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7743 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7744 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7745 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7746 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7747 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7748 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7749 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7750 	{ } /* end */
7751 };
7752 
7753 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7754 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7755 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7756 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7757 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7758 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7759 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7760 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7761 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7762 	{ } /* end */
7763 };
7764 
7765 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7766 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7767 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7768 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7769 	HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7770 	HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7771 						0x0d, 1, 0x0, HDA_OUTPUT),
7772 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7773 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7774 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7775 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7776 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7777 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7778 	HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
7779 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7780 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7781 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7782 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7783 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7784 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7785 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7786 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7787 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7788 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7789 	{ } /* end */
7790 };
7791 
7792 static struct hda_bind_ctls alc883_bind_cap_vol = {
7793 	.ops = &snd_hda_bind_vol,
7794 	.values = {
7795 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7796 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7797 		0
7798 	},
7799 };
7800 
7801 static struct hda_bind_ctls alc883_bind_cap_switch = {
7802 	.ops = &snd_hda_bind_sw,
7803 	.values = {
7804 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7805 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7806 		0
7807 	},
7808 };
7809 
7810 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7811 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7812 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7813 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7814 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7815 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7816 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7817 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7818 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7819 	{ } /* end */
7820 };
7821 
7822 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7823 	HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7824 	HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7825 	{
7826 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7827 		/* .name = "Capture Source", */
7828 		.name = "Input Source",
7829 		.count = 1,
7830 		.info = alc_mux_enum_info,
7831 		.get = alc_mux_enum_get,
7832 		.put = alc_mux_enum_put,
7833 	},
7834 	{ } /* end */
7835 };
7836 
7837 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7838 	{
7839 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7840 		.name = "Channel Mode",
7841 		.info = alc_ch_mode_info,
7842 		.get = alc_ch_mode_get,
7843 		.put = alc_ch_mode_put,
7844 	},
7845 	{ } /* end */
7846 };
7847 
7848 static struct hda_verb alc883_init_verbs[] = {
7849 	/* ADC1: mute amp left and right */
7850 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7851 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7852 	/* ADC2: mute amp left and right */
7853 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7854 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7855 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7856 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7857 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7858 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7859 	/* Rear mixer */
7860 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7861 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7862 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7863 	/* CLFE mixer */
7864 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7865 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7866 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7867 	/* Side mixer */
7868 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7869 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7870 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7871 
7872 	/* mute analog input loopbacks */
7873 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7874 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7875 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7876 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7877 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7878 
7879 	/* Front Pin: output 0 (0x0c) */
7880 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7881 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7882 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7883 	/* Rear Pin: output 1 (0x0d) */
7884 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7885 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7886 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7887 	/* CLFE Pin: output 2 (0x0e) */
7888 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7889 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7890 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7891 	/* Side Pin: output 3 (0x0f) */
7892 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7893 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7894 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7895 	/* Mic (rear) pin: input vref at 80% */
7896 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7897 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7898 	/* Front Mic pin: input vref at 80% */
7899 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7900 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7901 	/* Line In pin: input */
7902 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7903 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7904 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
7905 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7906 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7907 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7908 	/* CD pin widget for input */
7909 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7910 
7911 	/* FIXME: use matrix-type input source selection */
7912 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7913 	/* Input mixer2 */
7914 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7915 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7916 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7917 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7918 	/* Input mixer3 */
7919 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7920 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7921 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7922 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7923 	{ }
7924 };
7925 
7926 /* toggle speaker-output according to the hp-jack state */
7927 static void alc883_mitac_hp_automute(struct hda_codec *codec)
7928 {
7929 	unsigned int present;
7930 
7931 	present = snd_hda_codec_read(codec, 0x15, 0,
7932 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7933 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7934 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7935 	snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
7936 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7937 }
7938 
7939 /* auto-toggle front mic */
7940 /*
7941 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7942 {
7943 	unsigned int present;
7944 	unsigned char bits;
7945 
7946 	present = snd_hda_codec_read(codec, 0x18, 0,
7947 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7948 	bits = present ? HDA_AMP_MUTE : 0;
7949 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7950 }
7951 */
7952 
7953 static void alc883_mitac_automute(struct hda_codec *codec)
7954 {
7955 	alc883_mitac_hp_automute(codec);
7956 	/* alc883_mitac_mic_automute(codec); */
7957 }
7958 
7959 static void alc883_mitac_unsol_event(struct hda_codec *codec,
7960 					   unsigned int res)
7961 {
7962 	switch (res >> 26) {
7963 	case ALC880_HP_EVENT:
7964 		alc883_mitac_hp_automute(codec);
7965 		break;
7966 	case ALC880_MIC_EVENT:
7967 		/* alc883_mitac_mic_automute(codec); */
7968 		break;
7969 	}
7970 }
7971 
7972 static struct hda_verb alc883_mitac_verbs[] = {
7973 	/* HP */
7974 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7975 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7976 	/* Subwoofer */
7977 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7978 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7979 
7980 	/* enable unsolicited event */
7981 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7982 	/* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7983 
7984 	{ } /* end */
7985 };
7986 
7987 static struct hda_verb alc883_clevo_m720_verbs[] = {
7988 	/* HP */
7989 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7990 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7991 	/* Int speaker */
7992 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7993 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7994 
7995 	/* enable unsolicited event */
7996 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7997 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7998 
7999 	{ } /* end */
8000 };
8001 
8002 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8003 	/* HP */
8004 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8005 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8006 	/* Subwoofer */
8007 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8008 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8009 
8010 	/* enable unsolicited event */
8011 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8012 
8013 	{ } /* end */
8014 };
8015 
8016 static struct hda_verb alc883_tagra_verbs[] = {
8017 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8018 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8019 
8020 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8021 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8022 
8023 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8024 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8025 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8026 
8027 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8028 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
8029 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
8030 	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
8031 
8032 	{ } /* end */
8033 };
8034 
8035 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8036 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8037 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8038         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8039 	{ } /* end */
8040 };
8041 
8042 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8043         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8044 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8045         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8046         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8047 	{ } /* end */
8048 };
8049 
8050 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8051 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8052 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8053 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8054 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8055 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8056 	{ } /* end */
8057 };
8058 
8059 static struct hda_verb alc883_haier_w66_verbs[] = {
8060 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8061 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8062 
8063 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8064 
8065 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8066 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8067 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8068 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8069 	{ } /* end */
8070 };
8071 
8072 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8073 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8074 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8075 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8076 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8077 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8078 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8079 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8080 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8081 	{ } /* end */
8082 };
8083 
8084 static struct hda_verb alc888_6st_dell_verbs[] = {
8085 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8086 	{ }
8087 };
8088 
8089 static void alc888_3st_hp_front_automute(struct hda_codec *codec)
8090 {
8091 	unsigned int present, bits;
8092 
8093 	present = snd_hda_codec_read(codec, 0x1b, 0,
8094 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8095 	bits = present ? HDA_AMP_MUTE : 0;
8096 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8097 				 HDA_AMP_MUTE, bits);
8098 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8099 				 HDA_AMP_MUTE, bits);
8100 	snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
8101 				 HDA_AMP_MUTE, bits);
8102 }
8103 
8104 static void alc888_3st_hp_unsol_event(struct hda_codec *codec,
8105 				      unsigned int res)
8106 {
8107 	switch (res >> 26) {
8108 	case ALC880_HP_EVENT:
8109 		alc888_3st_hp_front_automute(codec);
8110 		break;
8111 	}
8112 }
8113 
8114 static struct hda_verb alc888_3st_hp_verbs[] = {
8115 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Front: output 0 (0x0c) */
8116 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Rear : output 1 (0x0d) */
8117 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},	/* CLFE : output 2 (0x0e) */
8118 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8119 	{ } /* end */
8120 };
8121 
8122 /*
8123  * 2ch mode
8124  */
8125 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8126 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8127 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8128 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8129 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8130 	{ } /* end */
8131 };
8132 
8133 /*
8134  * 4ch mode
8135  */
8136 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8137 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8138 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8139 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8140 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8141 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8142 	{ } /* end */
8143 };
8144 
8145 /*
8146  * 6ch mode
8147  */
8148 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8149 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8150 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8151 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8152 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8153 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8154 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8155 	{ } /* end */
8156 };
8157 
8158 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8159 	{ 2, alc888_3st_hp_2ch_init },
8160 	{ 4, alc888_3st_hp_4ch_init },
8161 	{ 6, alc888_3st_hp_6ch_init },
8162 };
8163 
8164 /* toggle front-jack and RCA according to the hp-jack state */
8165 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8166 {
8167  	unsigned int present;
8168 
8169  	present = snd_hda_codec_read(codec, 0x1b, 0,
8170 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8171 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8172 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8173 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8174 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8175 }
8176 
8177 /* toggle RCA according to the front-jack state */
8178 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8179 {
8180  	unsigned int present;
8181 
8182  	present = snd_hda_codec_read(codec, 0x14, 0,
8183 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8184 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8185 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8186 }
8187 
8188 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8189 					     unsigned int res)
8190 {
8191 	if ((res >> 26) == ALC880_HP_EVENT)
8192 		alc888_lenovo_ms7195_front_automute(codec);
8193 	if ((res >> 26) == ALC880_FRONT_EVENT)
8194 		alc888_lenovo_ms7195_rca_automute(codec);
8195 }
8196 
8197 static struct hda_verb alc883_medion_md2_verbs[] = {
8198 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8199 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8200 
8201 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8202 
8203 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8204 	{ } /* end */
8205 };
8206 
8207 /* toggle speaker-output according to the hp-jack state */
8208 static void alc883_medion_md2_automute(struct hda_codec *codec)
8209 {
8210  	unsigned int present;
8211 
8212  	present = snd_hda_codec_read(codec, 0x14, 0,
8213 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8214 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8215 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8216 }
8217 
8218 static void alc883_medion_md2_unsol_event(struct hda_codec *codec,
8219 					  unsigned int res)
8220 {
8221 	if ((res >> 26) == ALC880_HP_EVENT)
8222 		alc883_medion_md2_automute(codec);
8223 }
8224 
8225 /* toggle speaker-output according to the hp-jack state */
8226 static void alc883_tagra_automute(struct hda_codec *codec)
8227 {
8228  	unsigned int present;
8229 	unsigned char bits;
8230 
8231  	present = snd_hda_codec_read(codec, 0x14, 0,
8232 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8233 	bits = present ? HDA_AMP_MUTE : 0;
8234 	snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
8235 				 HDA_AMP_MUTE, bits);
8236 	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8237 				  present ? 1 : 3);
8238 }
8239 
8240 static void alc883_tagra_unsol_event(struct hda_codec *codec, unsigned int res)
8241 {
8242 	if ((res >> 26) == ALC880_HP_EVENT)
8243 		alc883_tagra_automute(codec);
8244 }
8245 
8246 /* toggle speaker-output according to the hp-jack state */
8247 static void alc883_clevo_m720_hp_automute(struct hda_codec *codec)
8248 {
8249 	unsigned int present;
8250 	unsigned char bits;
8251 
8252 	present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
8253 		& AC_PINSENSE_PRESENCE;
8254 	bits = present ? HDA_AMP_MUTE : 0;
8255 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8256 				 HDA_AMP_MUTE, bits);
8257 }
8258 
8259 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8260 {
8261 	unsigned int present;
8262 
8263 	present = snd_hda_codec_read(codec, 0x18, 0,
8264 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8265 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8266 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8267 }
8268 
8269 static void alc883_clevo_m720_automute(struct hda_codec *codec)
8270 {
8271 	alc883_clevo_m720_hp_automute(codec);
8272 	alc883_clevo_m720_mic_automute(codec);
8273 }
8274 
8275 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8276 					   unsigned int res)
8277 {
8278 	switch (res >> 26) {
8279 	case ALC880_HP_EVENT:
8280 		alc883_clevo_m720_hp_automute(codec);
8281 		break;
8282 	case ALC880_MIC_EVENT:
8283 		alc883_clevo_m720_mic_automute(codec);
8284 		break;
8285 	}
8286 }
8287 
8288 /* toggle speaker-output according to the hp-jack state */
8289 static void alc883_2ch_fujitsu_pi2515_automute(struct hda_codec *codec)
8290 {
8291  	unsigned int present;
8292 	unsigned char bits;
8293 
8294  	present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8295 		& AC_PINSENSE_PRESENCE;
8296 	bits = present ? HDA_AMP_MUTE : 0;
8297 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8298 				 HDA_AMP_MUTE, bits);
8299 }
8300 
8301 static void alc883_2ch_fujitsu_pi2515_unsol_event(struct hda_codec *codec,
8302 						  unsigned int res)
8303 {
8304 	if ((res >> 26) == ALC880_HP_EVENT)
8305 		alc883_2ch_fujitsu_pi2515_automute(codec);
8306 }
8307 
8308 static void alc883_haier_w66_automute(struct hda_codec *codec)
8309 {
8310 	unsigned int present;
8311 	unsigned char bits;
8312 
8313 	present = snd_hda_codec_read(codec, 0x1b, 0,
8314 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8315 	bits = present ? 0x80 : 0;
8316 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8317 				 0x80, bits);
8318 }
8319 
8320 static void alc883_haier_w66_unsol_event(struct hda_codec *codec,
8321 					 unsigned int res)
8322 {
8323 	if ((res >> 26) == ALC880_HP_EVENT)
8324 		alc883_haier_w66_automute(codec);
8325 }
8326 
8327 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8328 {
8329  	unsigned int present;
8330 	unsigned char bits;
8331 
8332  	present = snd_hda_codec_read(codec, 0x14, 0,
8333 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8334 	bits = present ? HDA_AMP_MUTE : 0;
8335 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8336 				 HDA_AMP_MUTE, bits);
8337 }
8338 
8339 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8340 {
8341  	unsigned int present;
8342 	unsigned char bits;
8343 
8344  	present = snd_hda_codec_read(codec, 0x1b, 0,
8345 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8346 	bits = present ? HDA_AMP_MUTE : 0;
8347 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8348 				 HDA_AMP_MUTE, bits);
8349 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8350 				 HDA_AMP_MUTE, bits);
8351 }
8352 
8353 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8354 					   unsigned int res)
8355 {
8356 	if ((res >> 26) == ALC880_HP_EVENT)
8357 		alc883_lenovo_101e_all_automute(codec);
8358 	if ((res >> 26) == ALC880_FRONT_EVENT)
8359 		alc883_lenovo_101e_ispeaker_automute(codec);
8360 }
8361 
8362 /* toggle speaker-output according to the hp-jack state */
8363 static void alc883_acer_aspire_automute(struct hda_codec *codec)
8364 {
8365  	unsigned int present;
8366 
8367  	present = snd_hda_codec_read(codec, 0x14, 0,
8368 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8369 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8370 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8371 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8372 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8373 }
8374 
8375 static void alc883_acer_aspire_unsol_event(struct hda_codec *codec,
8376 					   unsigned int res)
8377 {
8378 	if ((res >> 26) == ALC880_HP_EVENT)
8379 		alc883_acer_aspire_automute(codec);
8380 }
8381 
8382 static struct hda_verb alc883_acer_eapd_verbs[] = {
8383 	/* HP Pin: output 0 (0x0c) */
8384 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8385 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8386 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8387 	/* Front Pin: output 0 (0x0c) */
8388 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8389 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8390 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8391 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8392         /* eanable EAPD on medion laptop */
8393 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8394 	{0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8395 	/* enable unsolicited event */
8396 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8397 	{ }
8398 };
8399 
8400 static void alc888_6st_dell_front_automute(struct hda_codec *codec)
8401 {
8402  	unsigned int present;
8403 
8404  	present = snd_hda_codec_read(codec, 0x1b, 0,
8405 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8406 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8407 				HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8408 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8409 				HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8410 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8411 				HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8412 	snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8413 				HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8414 }
8415 
8416 static void alc888_6st_dell_unsol_event(struct hda_codec *codec,
8417 					     unsigned int res)
8418 {
8419 	switch (res >> 26) {
8420 	case ALC880_HP_EVENT:
8421 		/* printk(KERN_DEBUG "hp_event\n"); */
8422 		alc888_6st_dell_front_automute(codec);
8423 		break;
8424 	}
8425 }
8426 
8427 static void alc888_lenovo_sky_front_automute(struct hda_codec *codec)
8428 {
8429 	unsigned int mute;
8430 	unsigned int present;
8431 
8432 	snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
8433 	present = snd_hda_codec_read(codec, 0x1b, 0,
8434 				     AC_VERB_GET_PIN_SENSE, 0);
8435 	present = (present & 0x80000000) != 0;
8436 	if (present) {
8437 		/* mute internal speaker */
8438 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8439 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
8440 		snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8441 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
8442 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8443 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
8444 		snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8445 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
8446 		snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8447 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
8448 	} else {
8449 		/* unmute internal speaker if necessary */
8450 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
8451 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8452 					 HDA_AMP_MUTE, mute);
8453 		snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8454 					 HDA_AMP_MUTE, mute);
8455 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8456 					 HDA_AMP_MUTE, mute);
8457 		snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
8458 					 HDA_AMP_MUTE, mute);
8459 		snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
8460 					 HDA_AMP_MUTE, mute);
8461 	}
8462 }
8463 
8464 static void alc883_lenovo_sky_unsol_event(struct hda_codec *codec,
8465 					     unsigned int res)
8466 {
8467 	if ((res >> 26) == ALC880_HP_EVENT)
8468 		alc888_lenovo_sky_front_automute(codec);
8469 }
8470 
8471 /*
8472  * generic initialization of ADC, input mixers and output mixers
8473  */
8474 static struct hda_verb alc883_auto_init_verbs[] = {
8475 	/*
8476 	 * Unmute ADC0-2 and set the default input to mic-in
8477 	 */
8478 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8479 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8480 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8481 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8482 
8483 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
8484 	 * mixer widget
8485 	 * Note: PASD motherboards uses the Line In 2 as the input for
8486 	 * front panel mic (mic 2)
8487 	 */
8488 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
8489 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8490 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8491 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8492 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8493 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8494 
8495 	/*
8496 	 * Set up output mixers (0x0c - 0x0f)
8497 	 */
8498 	/* set vol=0 to output mixers */
8499 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8500 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8501 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8502 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8503 	/* set up input amps for analog loopback */
8504 	/* Amp Indices: DAC = 0, mixer = 1 */
8505 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8506 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8507 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8508 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8509 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8510 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8511 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8512 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8513 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8514 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8515 
8516 	/* FIXME: use matrix-type input source selection */
8517 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8518 	/* Input mixer1 */
8519 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8520 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8521 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8522 	/* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8523 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8524 	/* Input mixer2 */
8525 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8526 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8527 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8528 	/* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)}, */
8529 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
8530 
8531 	{ }
8532 };
8533 
8534 static struct hda_verb alc888_asus_m90v_verbs[] = {
8535 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8536 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8537 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8538 	/* enable unsolicited event */
8539 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8540 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8541 	{ } /* end */
8542 };
8543 
8544 static void alc883_nb_mic_automute(struct hda_codec *codec)
8545 {
8546 	unsigned int present;
8547 
8548 	present = snd_hda_codec_read(codec, 0x18, 0,
8549 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8550 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8551 			    0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8552 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8553 			    0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8554 }
8555 
8556 static void alc883_M90V_speaker_automute(struct hda_codec *codec)
8557 {
8558 	unsigned int present;
8559 	unsigned char bits;
8560 
8561 	present = snd_hda_codec_read(codec, 0x1b, 0,
8562 				     AC_VERB_GET_PIN_SENSE, 0)
8563 		& AC_PINSENSE_PRESENCE;
8564 	bits = present ? 0 : PIN_OUT;
8565 	snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8566 			    bits);
8567 	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8568 			    bits);
8569 	snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8570 			    bits);
8571 }
8572 
8573 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8574 					   unsigned int res)
8575 {
8576 	switch (res >> 26) {
8577 	case ALC880_HP_EVENT:
8578 		alc883_M90V_speaker_automute(codec);
8579 		break;
8580 	case ALC880_MIC_EVENT:
8581 		alc883_nb_mic_automute(codec);
8582 		break;
8583 	}
8584 }
8585 
8586 static void alc883_mode2_inithook(struct hda_codec *codec)
8587 {
8588 	alc883_M90V_speaker_automute(codec);
8589 	alc883_nb_mic_automute(codec);
8590 }
8591 
8592 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8593 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8594 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8595 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8596 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8597 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8598 	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8599 	{0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8600 	/* enable unsolicited event */
8601 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8602 	{ } /* end */
8603 };
8604 
8605 static void alc883_eee1601_speaker_automute(struct hda_codec *codec)
8606 {
8607 	unsigned int present;
8608 	unsigned char bits;
8609 
8610 	present = snd_hda_codec_read(codec, 0x14, 0,
8611 				     AC_VERB_GET_PIN_SENSE, 0)
8612 		& AC_PINSENSE_PRESENCE;
8613 	bits = present ? 0 : PIN_OUT;
8614 	snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
8615 			    bits);
8616 }
8617 
8618 static void alc883_eee1601_unsol_event(struct hda_codec *codec,
8619 					   unsigned int res)
8620 {
8621 	switch (res >> 26) {
8622 	case ALC880_HP_EVENT:
8623 		alc883_eee1601_speaker_automute(codec);
8624 		break;
8625 	}
8626 }
8627 
8628 static void alc883_eee1601_inithook(struct hda_codec *codec)
8629 {
8630 	alc883_eee1601_speaker_automute(codec);
8631 }
8632 
8633 #ifdef CONFIG_SND_HDA_POWER_SAVE
8634 #define alc883_loopbacks	alc880_loopbacks
8635 #endif
8636 
8637 /* pcm configuration: identiacal with ALC880 */
8638 #define alc883_pcm_analog_playback	alc880_pcm_analog_playback
8639 #define alc883_pcm_analog_capture	alc880_pcm_analog_capture
8640 #define alc883_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
8641 #define alc883_pcm_digital_playback	alc880_pcm_digital_playback
8642 #define alc883_pcm_digital_capture	alc880_pcm_digital_capture
8643 
8644 /*
8645  * configuration and preset
8646  */
8647 static const char *alc883_models[ALC883_MODEL_LAST] = {
8648 	[ALC883_3ST_2ch_DIG]	= "3stack-dig",
8649 	[ALC883_3ST_6ch_DIG]	= "3stack-6ch-dig",
8650 	[ALC883_3ST_6ch]	= "3stack-6ch",
8651 	[ALC883_6ST_DIG]	= "6stack-dig",
8652 	[ALC883_TARGA_DIG]	= "targa-dig",
8653 	[ALC883_TARGA_2ch_DIG]	= "targa-2ch-dig",
8654 	[ALC883_ACER]		= "acer",
8655 	[ALC883_ACER_ASPIRE]	= "acer-aspire",
8656 	[ALC888_ACER_ASPIRE_4930G]	= "acer-aspire-4930g",
8657 	[ALC883_MEDION]		= "medion",
8658 	[ALC883_MEDION_MD2]	= "medion-md2",
8659 	[ALC883_LAPTOP_EAPD]	= "laptop-eapd",
8660 	[ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8661 	[ALC883_LENOVO_NB0763]	= "lenovo-nb0763",
8662 	[ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8663 	[ALC888_LENOVO_SKY] = "lenovo-sky",
8664 	[ALC883_HAIER_W66] 	= "haier-w66",
8665 	[ALC888_3ST_HP]		= "3stack-hp",
8666 	[ALC888_6ST_DELL]	= "6stack-dell",
8667 	[ALC883_MITAC]		= "mitac",
8668 	[ALC883_CLEVO_M720]	= "clevo-m720",
8669 	[ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8670 	[ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8671 	[ALC883_3ST_6ch_INTEL]	= "3stack-6ch-intel",
8672 	[ALC1200_ASUS_P5Q]	= "asus-p5q",
8673 	[ALC883_AUTO]		= "auto",
8674 };
8675 
8676 static struct snd_pci_quirk alc883_cfg_tbl[] = {
8677 	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
8678 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8679 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8680 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8681 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8682 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8683 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8684 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8685 		ALC888_ACER_ASPIRE_4930G),
8686 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8687 		ALC888_ACER_ASPIRE_4930G),
8688 	SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC883_AUTO),
8689 	SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC883_AUTO),
8690 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8691 		ALC888_ACER_ASPIRE_4930G),
8692 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8693 		ALC888_ACER_ASPIRE_4930G),
8694 	/* default Acer */
8695 	SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER),
8696 	SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8697 	SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8698 	SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8699 	SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8700 	SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8701 	SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8702 	SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8703 	SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8704 	SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8705 	SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8706 	SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8707 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8708 	SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8709 	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC883_6ST_DIG),
8710 	SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8711 	SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8712 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8713 	SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8714 	SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8715 	SND_PCI_QUIRK(0x1458, 0xa002, "MSI", ALC883_6ST_DIG),
8716 	SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8717 	SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8718 	SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8719 	SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8720 	SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8721 	SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8722 	SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8723 	SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8724 	SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8725 	SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8726 	SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8727 	SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8728 	SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8729 	SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8730 	SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8731 	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8732 	SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8733 	SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8734 	SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8735 	SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8736 	SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8737 	SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8738 	SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8739 	SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8740 	SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8741 	SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8742 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8743 	SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8744 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8745 	SND_PCI_QUIRK(0x1734, 0x1107, "FSC AMILO Xi2550",
8746 		      ALC883_FUJITSU_PI2515),
8747 	SND_PCI_QUIRK(0x1734, 0x1108, "Fujitsu AMILO Pi2515", ALC883_FUJITSU_PI2515),
8748 	SND_PCI_QUIRK(0x1734, 0x113d, "Fujitsu AMILO Xa3530",
8749 		ALC888_FUJITSU_XA3530),
8750 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8751 	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8752 	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8753 	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8754 	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8755 	SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8756 	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8757 	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8758 	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8759 	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8760 	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8761 	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8762 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8763 	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8764 	{}
8765 };
8766 
8767 static hda_nid_t alc1200_slave_dig_outs[] = {
8768 	ALC883_DIGOUT_NID, 0,
8769 };
8770 
8771 static struct alc_config_preset alc883_presets[] = {
8772 	[ALC883_3ST_2ch_DIG] = {
8773 		.mixers = { alc883_3ST_2ch_mixer },
8774 		.init_verbs = { alc883_init_verbs },
8775 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8776 		.dac_nids = alc883_dac_nids,
8777 		.dig_out_nid = ALC883_DIGOUT_NID,
8778 		.dig_in_nid = ALC883_DIGIN_NID,
8779 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8780 		.channel_mode = alc883_3ST_2ch_modes,
8781 		.input_mux = &alc883_capture_source,
8782 	},
8783 	[ALC883_3ST_6ch_DIG] = {
8784 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8785 		.init_verbs = { alc883_init_verbs },
8786 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8787 		.dac_nids = alc883_dac_nids,
8788 		.dig_out_nid = ALC883_DIGOUT_NID,
8789 		.dig_in_nid = ALC883_DIGIN_NID,
8790 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8791 		.channel_mode = alc883_3ST_6ch_modes,
8792 		.need_dac_fix = 1,
8793 		.input_mux = &alc883_capture_source,
8794 	},
8795 	[ALC883_3ST_6ch] = {
8796 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8797 		.init_verbs = { alc883_init_verbs },
8798 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8799 		.dac_nids = alc883_dac_nids,
8800 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8801 		.channel_mode = alc883_3ST_6ch_modes,
8802 		.need_dac_fix = 1,
8803 		.input_mux = &alc883_capture_source,
8804 	},
8805 	[ALC883_3ST_6ch_INTEL] = {
8806 		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8807 		.init_verbs = { alc883_init_verbs },
8808 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8809 		.dac_nids = alc883_dac_nids,
8810 		.dig_out_nid = ALC883_DIGOUT_NID,
8811 		.dig_in_nid = ALC883_DIGIN_NID,
8812 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8813 		.channel_mode = alc883_3ST_6ch_intel_modes,
8814 		.need_dac_fix = 1,
8815 		.input_mux = &alc883_3stack_6ch_intel,
8816 	},
8817 	[ALC883_6ST_DIG] = {
8818 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
8819 		.init_verbs = { alc883_init_verbs },
8820 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8821 		.dac_nids = alc883_dac_nids,
8822 		.dig_out_nid = ALC883_DIGOUT_NID,
8823 		.dig_in_nid = ALC883_DIGIN_NID,
8824 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8825 		.channel_mode = alc883_sixstack_modes,
8826 		.input_mux = &alc883_capture_source,
8827 	},
8828 	[ALC883_TARGA_DIG] = {
8829 		.mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8830 		.init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8831 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8832 		.dac_nids = alc883_dac_nids,
8833 		.dig_out_nid = ALC883_DIGOUT_NID,
8834 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8835 		.channel_mode = alc883_3ST_6ch_modes,
8836 		.need_dac_fix = 1,
8837 		.input_mux = &alc883_capture_source,
8838 		.unsol_event = alc883_tagra_unsol_event,
8839 		.init_hook = alc883_tagra_automute,
8840 	},
8841 	[ALC883_TARGA_2ch_DIG] = {
8842 		.mixers = { alc883_tagra_2ch_mixer},
8843 		.init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8844 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8845 		.dac_nids = alc883_dac_nids,
8846 		.adc_nids = alc883_adc_nids_alt,
8847 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8848 		.dig_out_nid = ALC883_DIGOUT_NID,
8849 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8850 		.channel_mode = alc883_3ST_2ch_modes,
8851 		.input_mux = &alc883_capture_source,
8852 		.unsol_event = alc883_tagra_unsol_event,
8853 		.init_hook = alc883_tagra_automute,
8854 	},
8855 	[ALC883_ACER] = {
8856 		.mixers = { alc883_base_mixer },
8857 		/* On TravelMate laptops, GPIO 0 enables the internal speaker
8858 		 * and the headphone jack.  Turn this on and rely on the
8859 		 * standard mute methods whenever the user wants to turn
8860 		 * these outputs off.
8861 		 */
8862 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8863 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8864 		.dac_nids = alc883_dac_nids,
8865 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8866 		.channel_mode = alc883_3ST_2ch_modes,
8867 		.input_mux = &alc883_capture_source,
8868 	},
8869 	[ALC883_ACER_ASPIRE] = {
8870 		.mixers = { alc883_acer_aspire_mixer },
8871 		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8872 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8873 		.dac_nids = alc883_dac_nids,
8874 		.dig_out_nid = ALC883_DIGOUT_NID,
8875 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8876 		.channel_mode = alc883_3ST_2ch_modes,
8877 		.input_mux = &alc883_capture_source,
8878 		.unsol_event = alc883_acer_aspire_unsol_event,
8879 		.init_hook = alc883_acer_aspire_automute,
8880 	},
8881 	[ALC888_ACER_ASPIRE_4930G] = {
8882 		.mixers = { alc888_base_mixer,
8883 				alc883_chmode_mixer },
8884 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8885 				alc888_acer_aspire_4930g_verbs },
8886 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8887 		.dac_nids = alc883_dac_nids,
8888 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8889 		.adc_nids = alc883_adc_nids_rev,
8890 		.capsrc_nids = alc883_capsrc_nids_rev,
8891 		.dig_out_nid = ALC883_DIGOUT_NID,
8892 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8893 		.channel_mode = alc883_3ST_6ch_modes,
8894 		.need_dac_fix = 1,
8895 		.num_mux_defs =
8896 			ARRAY_SIZE(alc888_2_capture_sources),
8897 		.input_mux = alc888_2_capture_sources,
8898 		.unsol_event = alc888_acer_aspire_4930g_unsol_event,
8899 		.init_hook = alc888_acer_aspire_4930g_automute,
8900 	},
8901 	[ALC883_MEDION] = {
8902 		.mixers = { alc883_fivestack_mixer,
8903 			    alc883_chmode_mixer },
8904 		.init_verbs = { alc883_init_verbs,
8905 				alc883_medion_eapd_verbs },
8906 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8907 		.dac_nids = alc883_dac_nids,
8908 		.adc_nids = alc883_adc_nids_alt,
8909 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8910 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8911 		.channel_mode = alc883_sixstack_modes,
8912 		.input_mux = &alc883_capture_source,
8913 	},
8914 	[ALC883_MEDION_MD2] = {
8915 		.mixers = { alc883_medion_md2_mixer},
8916 		.init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8917 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8918 		.dac_nids = alc883_dac_nids,
8919 		.dig_out_nid = ALC883_DIGOUT_NID,
8920 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8921 		.channel_mode = alc883_3ST_2ch_modes,
8922 		.input_mux = &alc883_capture_source,
8923 		.unsol_event = alc883_medion_md2_unsol_event,
8924 		.init_hook = alc883_medion_md2_automute,
8925 	},
8926 	[ALC883_LAPTOP_EAPD] = {
8927 		.mixers = { alc883_base_mixer },
8928 		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8929 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8930 		.dac_nids = alc883_dac_nids,
8931 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8932 		.channel_mode = alc883_3ST_2ch_modes,
8933 		.input_mux = &alc883_capture_source,
8934 	},
8935 	[ALC883_CLEVO_M720] = {
8936 		.mixers = { alc883_clevo_m720_mixer },
8937 		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8938 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8939 		.dac_nids = alc883_dac_nids,
8940 		.dig_out_nid = ALC883_DIGOUT_NID,
8941 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8942 		.channel_mode = alc883_3ST_2ch_modes,
8943 		.input_mux = &alc883_capture_source,
8944 		.unsol_event = alc883_clevo_m720_unsol_event,
8945 		.init_hook = alc883_clevo_m720_automute,
8946 	},
8947 	[ALC883_LENOVO_101E_2ch] = {
8948 		.mixers = { alc883_lenovo_101e_2ch_mixer},
8949 		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8950 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8951 		.dac_nids = alc883_dac_nids,
8952 		.adc_nids = alc883_adc_nids_alt,
8953 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8954 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8955 		.channel_mode = alc883_3ST_2ch_modes,
8956 		.input_mux = &alc883_lenovo_101e_capture_source,
8957 		.unsol_event = alc883_lenovo_101e_unsol_event,
8958 		.init_hook = alc883_lenovo_101e_all_automute,
8959 	},
8960 	[ALC883_LENOVO_NB0763] = {
8961 		.mixers = { alc883_lenovo_nb0763_mixer },
8962 		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8963 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8964 		.dac_nids = alc883_dac_nids,
8965 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8966 		.channel_mode = alc883_3ST_2ch_modes,
8967 		.need_dac_fix = 1,
8968 		.input_mux = &alc883_lenovo_nb0763_capture_source,
8969 		.unsol_event = alc883_medion_md2_unsol_event,
8970 		.init_hook = alc883_medion_md2_automute,
8971 	},
8972 	[ALC888_LENOVO_MS7195_DIG] = {
8973 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8974 		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8975 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8976 		.dac_nids = alc883_dac_nids,
8977 		.dig_out_nid = ALC883_DIGOUT_NID,
8978 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8979 		.channel_mode = alc883_3ST_6ch_modes,
8980 		.need_dac_fix = 1,
8981 		.input_mux = &alc883_capture_source,
8982 		.unsol_event = alc883_lenovo_ms7195_unsol_event,
8983 		.init_hook = alc888_lenovo_ms7195_front_automute,
8984 	},
8985 	[ALC883_HAIER_W66] = {
8986 		.mixers = { alc883_tagra_2ch_mixer},
8987 		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8988 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8989 		.dac_nids = alc883_dac_nids,
8990 		.dig_out_nid = ALC883_DIGOUT_NID,
8991 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8992 		.channel_mode = alc883_3ST_2ch_modes,
8993 		.input_mux = &alc883_capture_source,
8994 		.unsol_event = alc883_haier_w66_unsol_event,
8995 		.init_hook = alc883_haier_w66_automute,
8996 	},
8997 	[ALC888_3ST_HP] = {
8998 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8999 		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9000 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9001 		.dac_nids = alc883_dac_nids,
9002 		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9003 		.channel_mode = alc888_3st_hp_modes,
9004 		.need_dac_fix = 1,
9005 		.input_mux = &alc883_capture_source,
9006 		.unsol_event = alc888_3st_hp_unsol_event,
9007 		.init_hook = alc888_3st_hp_front_automute,
9008 	},
9009 	[ALC888_6ST_DELL] = {
9010 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9011 		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9012 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9013 		.dac_nids = alc883_dac_nids,
9014 		.dig_out_nid = ALC883_DIGOUT_NID,
9015 		.dig_in_nid = ALC883_DIGIN_NID,
9016 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9017 		.channel_mode = alc883_sixstack_modes,
9018 		.input_mux = &alc883_capture_source,
9019 		.unsol_event = alc888_6st_dell_unsol_event,
9020 		.init_hook = alc888_6st_dell_front_automute,
9021 	},
9022 	[ALC883_MITAC] = {
9023 		.mixers = { alc883_mitac_mixer },
9024 		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9025 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9026 		.dac_nids = alc883_dac_nids,
9027 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9028 		.channel_mode = alc883_3ST_2ch_modes,
9029 		.input_mux = &alc883_capture_source,
9030 		.unsol_event = alc883_mitac_unsol_event,
9031 		.init_hook = alc883_mitac_automute,
9032 	},
9033 	[ALC883_FUJITSU_PI2515] = {
9034 		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9035 		.init_verbs = { alc883_init_verbs,
9036 				alc883_2ch_fujitsu_pi2515_verbs},
9037 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9038 		.dac_nids = alc883_dac_nids,
9039 		.dig_out_nid = ALC883_DIGOUT_NID,
9040 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9041 		.channel_mode = alc883_3ST_2ch_modes,
9042 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9043 		.unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
9044 		.init_hook = alc883_2ch_fujitsu_pi2515_automute,
9045 	},
9046 	[ALC888_FUJITSU_XA3530] = {
9047 		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
9048 		.init_verbs = { alc883_init_verbs,
9049 			alc888_fujitsu_xa3530_verbs },
9050 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9051 		.dac_nids = alc883_dac_nids,
9052 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9053 		.adc_nids = alc883_adc_nids_rev,
9054 		.capsrc_nids = alc883_capsrc_nids_rev,
9055 		.dig_out_nid = ALC883_DIGOUT_NID,
9056 		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9057 		.channel_mode = alc888_4ST_8ch_intel_modes,
9058 		.num_mux_defs =
9059 			ARRAY_SIZE(alc888_2_capture_sources),
9060 		.input_mux = alc888_2_capture_sources,
9061 		.unsol_event = alc888_fujitsu_xa3530_unsol_event,
9062 		.init_hook = alc888_fujitsu_xa3530_automute,
9063 	},
9064 	[ALC888_LENOVO_SKY] = {
9065 		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9066 		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9067 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9068 		.dac_nids = alc883_dac_nids,
9069 		.dig_out_nid = ALC883_DIGOUT_NID,
9070 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9071 		.channel_mode = alc883_sixstack_modes,
9072 		.need_dac_fix = 1,
9073 		.input_mux = &alc883_lenovo_sky_capture_source,
9074 		.unsol_event = alc883_lenovo_sky_unsol_event,
9075 		.init_hook = alc888_lenovo_sky_front_automute,
9076 	},
9077 	[ALC888_ASUS_M90V] = {
9078 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9079 		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9080 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9081 		.dac_nids = alc883_dac_nids,
9082 		.dig_out_nid = ALC883_DIGOUT_NID,
9083 		.dig_in_nid = ALC883_DIGIN_NID,
9084 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9085 		.channel_mode = alc883_3ST_6ch_modes,
9086 		.need_dac_fix = 1,
9087 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9088 		.unsol_event = alc883_mode2_unsol_event,
9089 		.init_hook = alc883_mode2_inithook,
9090 	},
9091 	[ALC888_ASUS_EEE1601] = {
9092 		.mixers = { alc883_asus_eee1601_mixer },
9093 		.cap_mixer = alc883_asus_eee1601_cap_mixer,
9094 		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9095 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9096 		.dac_nids = alc883_dac_nids,
9097 		.dig_out_nid = ALC883_DIGOUT_NID,
9098 		.dig_in_nid = ALC883_DIGIN_NID,
9099 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9100 		.channel_mode = alc883_3ST_2ch_modes,
9101 		.need_dac_fix = 1,
9102 		.input_mux = &alc883_asus_eee1601_capture_source,
9103 		.unsol_event = alc883_eee1601_unsol_event,
9104 		.init_hook = alc883_eee1601_inithook,
9105 	},
9106 	[ALC1200_ASUS_P5Q] = {
9107 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9108 		.init_verbs = { alc883_init_verbs },
9109 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9110 		.dac_nids = alc883_dac_nids,
9111 		.dig_out_nid = ALC1200_DIGOUT_NID,
9112 		.dig_in_nid = ALC883_DIGIN_NID,
9113 		.slave_dig_outs = alc1200_slave_dig_outs,
9114 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9115 		.channel_mode = alc883_sixstack_modes,
9116 		.input_mux = &alc883_capture_source,
9117 	},
9118 };
9119 
9120 
9121 /*
9122  * BIOS auto configuration
9123  */
9124 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9125 					      hda_nid_t nid, int pin_type,
9126 					      int dac_idx)
9127 {
9128 	/* set as output */
9129 	struct alc_spec *spec = codec->spec;
9130 	int idx;
9131 
9132 	alc_set_pin_output(codec, nid, pin_type);
9133 	if (spec->multiout.dac_nids[dac_idx] == 0x25)
9134 		idx = 4;
9135 	else
9136 		idx = spec->multiout.dac_nids[dac_idx] - 2;
9137 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9138 
9139 }
9140 
9141 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9142 {
9143 	struct alc_spec *spec = codec->spec;
9144 	int i;
9145 
9146 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
9147 	for (i = 0; i <= HDA_SIDE; i++) {
9148 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
9149 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
9150 		if (nid)
9151 			alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9152 							  i);
9153 	}
9154 }
9155 
9156 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9157 {
9158 	struct alc_spec *spec = codec->spec;
9159 	hda_nid_t pin;
9160 
9161 	pin = spec->autocfg.hp_pins[0];
9162 	if (pin) /* connect to front */
9163 		/* use dac 0 */
9164 		alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9165 	pin = spec->autocfg.speaker_pins[0];
9166 	if (pin)
9167 		alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9168 }
9169 
9170 #define alc883_is_input_pin(nid)	alc880_is_input_pin(nid)
9171 #define ALC883_PIN_CD_NID		ALC880_PIN_CD_NID
9172 
9173 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9174 {
9175 	struct alc_spec *spec = codec->spec;
9176 	int i;
9177 
9178 	for (i = 0; i < AUTO_PIN_LAST; i++) {
9179 		hda_nid_t nid = spec->autocfg.input_pins[i];
9180 		if (alc883_is_input_pin(nid)) {
9181 			alc_set_input_pin(codec, nid, i);
9182 			if (nid != ALC883_PIN_CD_NID &&
9183 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
9184 				snd_hda_codec_write(codec, nid, 0,
9185 						    AC_VERB_SET_AMP_GAIN_MUTE,
9186 						    AMP_OUT_MUTE);
9187 		}
9188 	}
9189 }
9190 
9191 #define alc883_auto_init_input_src	alc882_auto_init_input_src
9192 
9193 /* almost identical with ALC880 parser... */
9194 static int alc883_parse_auto_config(struct hda_codec *codec)
9195 {
9196 	struct alc_spec *spec = codec->spec;
9197 	int err = alc880_parse_auto_config(codec);
9198 	struct auto_pin_cfg *cfg = &spec->autocfg;
9199 	int i;
9200 
9201 	if (err < 0)
9202 		return err;
9203 	else if (!err)
9204 		return 0; /* no config found */
9205 
9206 	err = alc_auto_add_mic_boost(codec);
9207 	if (err < 0)
9208 		return err;
9209 
9210 	/* hack - override the init verbs */
9211 	spec->init_verbs[0] = alc883_auto_init_verbs;
9212 
9213 	/* setup input_mux for ALC889 */
9214 	if (codec->vendor_id == 0x10ec0889) {
9215 		/* digital-mic input pin is excluded in alc880_auto_create..()
9216 		 * because it's under 0x18
9217 		 */
9218 		if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9219 		    cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9220 			struct hda_input_mux *imux = &spec->private_imux[0];
9221 			for (i = 1; i < 3; i++)
9222 				memcpy(&spec->private_imux[i],
9223 				       &spec->private_imux[0],
9224 				       sizeof(spec->private_imux[0]));
9225 			imux->items[imux->num_items].label = "Int DMic";
9226 			imux->items[imux->num_items].index = 0x0b;
9227 			imux->num_items++;
9228 			spec->num_mux_defs = 3;
9229 			spec->input_mux = spec->private_imux;
9230 		}
9231 	}
9232 
9233 	return 1; /* config found */
9234 }
9235 
9236 /* additional initialization for auto-configuration model */
9237 static void alc883_auto_init(struct hda_codec *codec)
9238 {
9239 	struct alc_spec *spec = codec->spec;
9240 	alc883_auto_init_multi_out(codec);
9241 	alc883_auto_init_hp_out(codec);
9242 	alc883_auto_init_analog_input(codec);
9243 	alc883_auto_init_input_src(codec);
9244 	if (spec->unsol_event)
9245 		alc_inithook(codec);
9246 }
9247 
9248 static int patch_alc883(struct hda_codec *codec)
9249 {
9250 	struct alc_spec *spec;
9251 	int err, board_config;
9252 
9253 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9254 	if (spec == NULL)
9255 		return -ENOMEM;
9256 
9257 	codec->spec = spec;
9258 
9259 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9260 
9261 	board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9262 						  alc883_models,
9263 						  alc883_cfg_tbl);
9264 	if (board_config < 0) {
9265 		printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9266 		       "trying auto-probe from BIOS...\n");
9267 		board_config = ALC883_AUTO;
9268 	}
9269 
9270 	if (board_config == ALC883_AUTO) {
9271 		/* automatic parse from the BIOS config */
9272 		err = alc883_parse_auto_config(codec);
9273 		if (err < 0) {
9274 			alc_free(codec);
9275 			return err;
9276 		} else if (!err) {
9277 			printk(KERN_INFO
9278 			       "hda_codec: Cannot set up configuration "
9279 			       "from BIOS.  Using base mode...\n");
9280 			board_config = ALC883_3ST_2ch_DIG;
9281 		}
9282 	}
9283 
9284 	err = snd_hda_attach_beep_device(codec, 0x1);
9285 	if (err < 0) {
9286 		alc_free(codec);
9287 		return err;
9288 	}
9289 
9290 	if (board_config != ALC883_AUTO)
9291 		setup_preset(spec, &alc883_presets[board_config]);
9292 
9293 	switch (codec->vendor_id) {
9294 	case 0x10ec0888:
9295 		if (codec->revision_id == 0x100101) {
9296 			spec->stream_name_analog = "ALC1200 Analog";
9297 			spec->stream_name_digital = "ALC1200 Digital";
9298 		} else {
9299 			spec->stream_name_analog = "ALC888 Analog";
9300 			spec->stream_name_digital = "ALC888 Digital";
9301 		}
9302 		if (!spec->num_adc_nids) {
9303 			spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9304 			spec->adc_nids = alc883_adc_nids;
9305 		}
9306 		if (!spec->capsrc_nids)
9307 			spec->capsrc_nids = alc883_capsrc_nids;
9308 		spec->capture_style = CAPT_MIX; /* matrix-style capture */
9309 		break;
9310 	case 0x10ec0889:
9311 		spec->stream_name_analog = "ALC889 Analog";
9312 		spec->stream_name_digital = "ALC889 Digital";
9313 		if (!spec->num_adc_nids) {
9314 			spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9315 			spec->adc_nids = alc889_adc_nids;
9316 		}
9317 		if (!spec->capsrc_nids)
9318 			spec->capsrc_nids = alc889_capsrc_nids;
9319 		spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9320 							capture */
9321 		break;
9322 	default:
9323 		spec->stream_name_analog = "ALC883 Analog";
9324 		spec->stream_name_digital = "ALC883 Digital";
9325 		if (!spec->num_adc_nids) {
9326 			spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9327 			spec->adc_nids = alc883_adc_nids;
9328 		}
9329 		if (!spec->capsrc_nids)
9330 			spec->capsrc_nids = alc883_capsrc_nids;
9331 		spec->capture_style = CAPT_MIX; /* matrix-style capture */
9332 		break;
9333 	}
9334 
9335 	spec->stream_analog_playback = &alc883_pcm_analog_playback;
9336 	spec->stream_analog_capture = &alc883_pcm_analog_capture;
9337 	spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9338 
9339 	spec->stream_digital_playback = &alc883_pcm_digital_playback;
9340 	spec->stream_digital_capture = &alc883_pcm_digital_capture;
9341 
9342 	if (!spec->cap_mixer)
9343 		set_capture_mixer(spec);
9344 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9345 
9346 	spec->vmaster_nid = 0x0c;
9347 
9348 	codec->patch_ops = alc_patch_ops;
9349 	if (board_config == ALC883_AUTO)
9350 		spec->init_hook = alc883_auto_init;
9351 
9352 #ifdef CONFIG_SND_HDA_POWER_SAVE
9353 	if (!spec->loopback.amplist)
9354 		spec->loopback.amplist = alc883_loopbacks;
9355 #endif
9356 	codec->proc_widget_hook = print_realtek_coef;
9357 
9358 	return 0;
9359 }
9360 
9361 /*
9362  * ALC262 support
9363  */
9364 
9365 #define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
9366 #define ALC262_DIGIN_NID	ALC880_DIGIN_NID
9367 
9368 #define alc262_dac_nids		alc260_dac_nids
9369 #define alc262_adc_nids		alc882_adc_nids
9370 #define alc262_adc_nids_alt	alc882_adc_nids_alt
9371 #define alc262_capsrc_nids	alc882_capsrc_nids
9372 #define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
9373 
9374 #define alc262_modes		alc260_modes
9375 #define alc262_capture_source	alc882_capture_source
9376 
9377 static hda_nid_t alc262_dmic_adc_nids[1] = {
9378 	/* ADC0 */
9379 	0x09
9380 };
9381 
9382 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9383 
9384 static struct snd_kcontrol_new alc262_base_mixer[] = {
9385 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9386 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9387 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9388 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9389 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9390 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9391 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9392 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9393 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9394 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9395 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9396 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9397 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9398 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9399 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9400 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9401 	{ } /* end */
9402 };
9403 
9404 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9405 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9406 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9407 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9408 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9409 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9410 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9411 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9412 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9413 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9414 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9415 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9416 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9417 	/*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9418 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9419 	{ } /* end */
9420 };
9421 
9422 /* update HP, line and mono-out pins according to the master switch */
9423 static void alc262_hp_master_update(struct hda_codec *codec)
9424 {
9425 	struct alc_spec *spec = codec->spec;
9426 	int val = spec->master_sw;
9427 
9428 	/* HP & line-out */
9429 	snd_hda_codec_write_cache(codec, 0x1b, 0,
9430 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
9431 				  val ? PIN_HP : 0);
9432 	snd_hda_codec_write_cache(codec, 0x15, 0,
9433 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
9434 				  val ? PIN_HP : 0);
9435 	/* mono (speaker) depending on the HP jack sense */
9436 	val = val && !spec->jack_present;
9437 	snd_hda_codec_write_cache(codec, 0x16, 0,
9438 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
9439 				  val ? PIN_OUT : 0);
9440 }
9441 
9442 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9443 {
9444 	struct alc_spec *spec = codec->spec;
9445 	unsigned int presence;
9446 	presence = snd_hda_codec_read(codec, 0x1b, 0,
9447 				      AC_VERB_GET_PIN_SENSE, 0);
9448 	spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9449 	alc262_hp_master_update(codec);
9450 }
9451 
9452 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9453 {
9454 	if ((res >> 26) != ALC880_HP_EVENT)
9455 		return;
9456 	alc262_hp_bpc_automute(codec);
9457 }
9458 
9459 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9460 {
9461 	struct alc_spec *spec = codec->spec;
9462 	unsigned int presence;
9463 	presence = snd_hda_codec_read(codec, 0x15, 0,
9464 				      AC_VERB_GET_PIN_SENSE, 0);
9465 	spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9466 	alc262_hp_master_update(codec);
9467 }
9468 
9469 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9470 					   unsigned int res)
9471 {
9472 	if ((res >> 26) != ALC880_HP_EVENT)
9473 		return;
9474 	alc262_hp_wildwest_automute(codec);
9475 }
9476 
9477 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9478 				   struct snd_ctl_elem_value *ucontrol)
9479 {
9480 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9481 	struct alc_spec *spec = codec->spec;
9482 	*ucontrol->value.integer.value = spec->master_sw;
9483 	return 0;
9484 }
9485 
9486 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9487 				   struct snd_ctl_elem_value *ucontrol)
9488 {
9489 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9490 	struct alc_spec *spec = codec->spec;
9491 	int val = !!*ucontrol->value.integer.value;
9492 
9493 	if (val == spec->master_sw)
9494 		return 0;
9495 	spec->master_sw = val;
9496 	alc262_hp_master_update(codec);
9497 	return 1;
9498 }
9499 
9500 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9501 	{
9502 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9503 		.name = "Master Playback Switch",
9504 		.info = snd_ctl_boolean_mono_info,
9505 		.get = alc262_hp_master_sw_get,
9506 		.put = alc262_hp_master_sw_put,
9507 	},
9508 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9509 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9510 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9511 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9512 			      HDA_OUTPUT),
9513 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9514 			    HDA_OUTPUT),
9515 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9516 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9517 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9518 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9519 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9520 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9521 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9522 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9523 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9524 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9525 	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9526 	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9527 	{ } /* end */
9528 };
9529 
9530 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9531 	{
9532 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9533 		.name = "Master Playback Switch",
9534 		.info = snd_ctl_boolean_mono_info,
9535 		.get = alc262_hp_master_sw_get,
9536 		.put = alc262_hp_master_sw_put,
9537 	},
9538 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9539 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9540 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9541 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9542 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9543 			      HDA_OUTPUT),
9544 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9545 			    HDA_OUTPUT),
9546 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9547 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9548 	HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9549 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9550 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9551 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9552 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9553 	{ } /* end */
9554 };
9555 
9556 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9557 	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9558 	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9559 	HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9560 	{ } /* end */
9561 };
9562 
9563 /* mute/unmute internal speaker according to the hp jack and mute state */
9564 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9565 {
9566 	struct alc_spec *spec = codec->spec;
9567 
9568 	if (force || !spec->sense_updated) {
9569 		unsigned int present;
9570 		present = snd_hda_codec_read(codec, 0x15, 0,
9571 					     AC_VERB_GET_PIN_SENSE, 0);
9572 		spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9573 		spec->sense_updated = 1;
9574 	}
9575 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9576 				 spec->jack_present ? HDA_AMP_MUTE : 0);
9577 }
9578 
9579 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9580 					unsigned int res)
9581 {
9582 	if ((res >> 26) != ALC880_HP_EVENT)
9583 		return;
9584 	alc262_hp_t5735_automute(codec, 1);
9585 }
9586 
9587 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9588 {
9589 	alc262_hp_t5735_automute(codec, 1);
9590 }
9591 
9592 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9593 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9594 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9595 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9596 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9597 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9598 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9599 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9600 	{ } /* end */
9601 };
9602 
9603 static struct hda_verb alc262_hp_t5735_verbs[] = {
9604 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9605 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9606 
9607 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9608 	{ }
9609 };
9610 
9611 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9612 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9613 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9614 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9615 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9616 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9617 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9618 	{ } /* end */
9619 };
9620 
9621 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9622 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9623 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9624 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9625 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9626 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9627 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9628 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9629 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9630 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9631 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9632 	{}
9633 };
9634 
9635 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9636 	.num_items = 1,
9637 	.items = {
9638 		{ "Line", 0x1 },
9639 	},
9640 };
9641 
9642 /* bind hp and internal speaker mute (with plug check) */
9643 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9644 				     struct snd_ctl_elem_value *ucontrol)
9645 {
9646 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9647 	long *valp = ucontrol->value.integer.value;
9648 	int change;
9649 
9650 	/* change hp mute */
9651 	change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9652 					  HDA_AMP_MUTE,
9653 					  valp[0] ? 0 : HDA_AMP_MUTE);
9654 	change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9655 					   HDA_AMP_MUTE,
9656 					   valp[1] ? 0 : HDA_AMP_MUTE);
9657 	if (change) {
9658 		/* change speaker according to HP jack state */
9659 		struct alc_spec *spec = codec->spec;
9660 		unsigned int mute;
9661 		if (spec->jack_present)
9662 			mute = HDA_AMP_MUTE;
9663 		else
9664 			mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9665 						      HDA_OUTPUT, 0);
9666 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9667 					 HDA_AMP_MUTE, mute);
9668 	}
9669 	return change;
9670 }
9671 
9672 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9673 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9674 	{
9675 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9676 		.name = "Master Playback Switch",
9677 		.info = snd_hda_mixer_amp_switch_info,
9678 		.get = snd_hda_mixer_amp_switch_get,
9679 		.put = alc262_sony_master_sw_put,
9680 		.private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9681 	},
9682 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9683 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9684 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9685 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9686 	{ } /* end */
9687 };
9688 
9689 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9690 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9691 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9692 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9693 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9694 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9695 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9696 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9697 	{ } /* end */
9698 };
9699 
9700 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9701 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9702 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9703 	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9704 	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9705 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9706 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9707 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9708 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9709 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9710 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9711 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9712 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9713 	{ } /* end */
9714 };
9715 
9716 static struct hda_verb alc262_tyan_verbs[] = {
9717 	/* Headphone automute */
9718 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9719 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9720 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9721 
9722 	/* P11 AUX_IN, white 4-pin connector */
9723 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9724 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9725 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9726 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9727 
9728 	{}
9729 };
9730 
9731 /* unsolicited event for HP jack sensing */
9732 static void alc262_tyan_automute(struct hda_codec *codec)
9733 {
9734 	unsigned int mute;
9735 	unsigned int present;
9736 
9737 	snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9738 	present = snd_hda_codec_read(codec, 0x1b, 0,
9739 				     AC_VERB_GET_PIN_SENSE, 0);
9740 	present = (present & 0x80000000) != 0;
9741 	if (present) {
9742 		/* mute line output on ATX panel */
9743 		snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9744 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
9745 	} else {
9746 		/* unmute line output if necessary */
9747 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9748 		snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9749 					 HDA_AMP_MUTE, mute);
9750 	}
9751 }
9752 
9753 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9754 				       unsigned int res)
9755 {
9756 	if ((res >> 26) != ALC880_HP_EVENT)
9757 		return;
9758 	alc262_tyan_automute(codec);
9759 }
9760 
9761 #define alc262_capture_mixer		alc882_capture_mixer
9762 #define alc262_capture_alt_mixer	alc882_capture_alt_mixer
9763 
9764 /*
9765  * generic initialization of ADC, input mixers and output mixers
9766  */
9767 static struct hda_verb alc262_init_verbs[] = {
9768 	/*
9769 	 * Unmute ADC0-2 and set the default input to mic-in
9770 	 */
9771 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9772 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9773 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9774 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9775 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9776 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9777 
9778 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9779 	 * mixer widget
9780 	 * Note: PASD motherboards uses the Line In 2 as the input for
9781 	 * front panel mic (mic 2)
9782 	 */
9783 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9784 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9785 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9786 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9787 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9788 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9789 
9790 	/*
9791 	 * Set up output mixers (0x0c - 0x0e)
9792 	 */
9793 	/* set vol=0 to output mixers */
9794 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9795 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9796 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9797 	/* set up input amps for analog loopback */
9798 	/* Amp Indices: DAC = 0, mixer = 1 */
9799 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9800 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9801 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9802 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9803 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9804 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9805 
9806 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9807 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9808 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9809 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9810 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9811 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9812 
9813 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9814 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9815 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9816 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9817 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9818 
9819 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9820 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9821 
9822 	/* FIXME: use matrix-type input source selection */
9823 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9824 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9825 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9826 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9827 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9828 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9829 	/* Input mixer2 */
9830 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9831 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9832 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9833 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9834 	/* Input mixer3 */
9835 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9836 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9837 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9838 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9839 
9840 	{ }
9841 };
9842 
9843 static struct hda_verb alc262_eapd_verbs[] = {
9844 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9845 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9846 	{ }
9847 };
9848 
9849 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9850 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9851 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9852 	{}
9853 };
9854 
9855 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9856 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9857 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9858 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9859 
9860 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9861 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9862 	{}
9863 };
9864 
9865 static struct hda_verb alc262_sony_unsol_verbs[] = {
9866 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9867 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9868 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
9869 
9870 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9871 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9872 	{}
9873 };
9874 
9875 static struct hda_input_mux alc262_dmic_capture_source = {
9876 	.num_items = 2,
9877 	.items = {
9878 		{ "Int DMic", 0x9 },
9879 		{ "Mic", 0x0 },
9880 	},
9881 };
9882 
9883 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9884 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9885 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9886 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9887 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9888 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9889 	{ } /* end */
9890 };
9891 
9892 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9893 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9894 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9895 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9896 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9897 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9898 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9899 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9900 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9901 	{}
9902 };
9903 
9904 static void alc262_dmic_automute(struct hda_codec *codec)
9905 {
9906 	unsigned int present;
9907 
9908 	present = snd_hda_codec_read(codec, 0x18, 0,
9909 					AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9910 	snd_hda_codec_write(codec, 0x22, 0,
9911 				AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9912 }
9913 
9914 /* toggle speaker-output according to the hp-jack state */
9915 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9916 {
9917 	unsigned int present;
9918 	unsigned char bits;
9919 
9920 	present = snd_hda_codec_read(codec, 0x15, 0,
9921 					AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9922 	bits = present ? 0 : PIN_OUT;
9923 	snd_hda_codec_write(codec, 0x14, 0,
9924 					AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9925 }
9926 
9927 
9928 
9929 /* unsolicited event for HP jack sensing */
9930 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9931 				       unsigned int res)
9932 {
9933 	if ((res >> 26) == ALC880_HP_EVENT)
9934 		alc262_toshiba_s06_speaker_automute(codec);
9935 	if ((res >> 26) == ALC880_MIC_EVENT)
9936 		alc262_dmic_automute(codec);
9937 
9938 }
9939 
9940 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9941 {
9942 	alc262_toshiba_s06_speaker_automute(codec);
9943 	alc262_dmic_automute(codec);
9944 }
9945 
9946 /* mute/unmute internal speaker according to the hp jack and mute state */
9947 static void alc262_hippo_automute(struct hda_codec *codec)
9948 {
9949 	struct alc_spec *spec = codec->spec;
9950 	unsigned int mute;
9951 	unsigned int present;
9952 
9953 	/* need to execute and sync at first */
9954 	snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9955 	present = snd_hda_codec_read(codec, 0x15, 0,
9956 				     AC_VERB_GET_PIN_SENSE, 0);
9957 	spec->jack_present = (present & 0x80000000) != 0;
9958 	if (spec->jack_present) {
9959 		/* mute internal speaker */
9960 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9961 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
9962 	} else {
9963 		/* unmute internal speaker if necessary */
9964 		mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9965 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9966 					 HDA_AMP_MUTE, mute);
9967 	}
9968 }
9969 
9970 /* unsolicited event for HP jack sensing */
9971 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9972 				       unsigned int res)
9973 {
9974 	if ((res >> 26) != ALC880_HP_EVENT)
9975 		return;
9976 	alc262_hippo_automute(codec);
9977 }
9978 
9979 static void alc262_hippo1_automute(struct hda_codec *codec)
9980 {
9981 	unsigned int mute;
9982 	unsigned int present;
9983 
9984 	snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9985 	present = snd_hda_codec_read(codec, 0x1b, 0,
9986 				     AC_VERB_GET_PIN_SENSE, 0);
9987 	present = (present & 0x80000000) != 0;
9988 	if (present) {
9989 		/* mute internal speaker */
9990 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9991 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
9992 	} else {
9993 		/* unmute internal speaker if necessary */
9994 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9995 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9996 					 HDA_AMP_MUTE, mute);
9997 	}
9998 }
9999 
10000 /* unsolicited event for HP jack sensing */
10001 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
10002 				       unsigned int res)
10003 {
10004 	if ((res >> 26) != ALC880_HP_EVENT)
10005 		return;
10006 	alc262_hippo1_automute(codec);
10007 }
10008 
10009 /*
10010  * nec model
10011  *  0x15 = headphone
10012  *  0x16 = internal speaker
10013  *  0x18 = external mic
10014  */
10015 
10016 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10017 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10018 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10019 
10020 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10021 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10022 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10023 
10024 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10025 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10026 	{ } /* end */
10027 };
10028 
10029 static struct hda_verb alc262_nec_verbs[] = {
10030 	/* Unmute Speaker */
10031 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10032 
10033 	/* Headphone */
10034 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10035 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10036 
10037 	/* External mic to headphone */
10038 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10039 	/* External mic to speaker */
10040 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10041 	{}
10042 };
10043 
10044 /*
10045  * fujitsu model
10046  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10047  *  0x1b = port replicator headphone out
10048  */
10049 
10050 #define ALC_HP_EVENT	0x37
10051 
10052 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10053 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10054 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10055 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10056 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10057 	{}
10058 };
10059 
10060 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10061 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10062 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10063 	{}
10064 };
10065 
10066 static struct hda_input_mux alc262_fujitsu_capture_source = {
10067 	.num_items = 3,
10068 	.items = {
10069 		{ "Mic", 0x0 },
10070 		{ "Int Mic", 0x1 },
10071 		{ "CD", 0x4 },
10072 	},
10073 };
10074 
10075 static struct hda_input_mux alc262_HP_capture_source = {
10076 	.num_items = 5,
10077 	.items = {
10078 		{ "Mic", 0x0 },
10079 		{ "Front Mic", 0x1 },
10080 		{ "Line", 0x2 },
10081 		{ "CD", 0x4 },
10082 		{ "AUX IN", 0x6 },
10083 	},
10084 };
10085 
10086 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10087 	.num_items = 4,
10088 	.items = {
10089 		{ "Mic", 0x0 },
10090 		{ "Front Mic", 0x2 },
10091 		{ "Line", 0x1 },
10092 		{ "CD", 0x4 },
10093 	},
10094 };
10095 
10096 /* mute/unmute internal speaker according to the hp jacks and mute state */
10097 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10098 {
10099 	struct alc_spec *spec = codec->spec;
10100 	unsigned int mute;
10101 
10102 	if (force || !spec->sense_updated) {
10103 		unsigned int present;
10104 		/* need to execute and sync at first */
10105 		snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10106 		/* check laptop HP jack */
10107 		present = snd_hda_codec_read(codec, 0x14, 0,
10108 					     AC_VERB_GET_PIN_SENSE, 0);
10109 		/* need to execute and sync at first */
10110 		snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10111 		/* check docking HP jack */
10112 		present |= snd_hda_codec_read(codec, 0x1b, 0,
10113 					      AC_VERB_GET_PIN_SENSE, 0);
10114 		if (present & AC_PINSENSE_PRESENCE)
10115 			spec->jack_present = 1;
10116 		else
10117 			spec->jack_present = 0;
10118 		spec->sense_updated = 1;
10119 	}
10120 	/* unmute internal speaker only if both HPs are unplugged and
10121 	 * master switch is on
10122 	 */
10123 	if (spec->jack_present)
10124 		mute = HDA_AMP_MUTE;
10125 	else
10126 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10127 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10128 				 HDA_AMP_MUTE, mute);
10129 }
10130 
10131 /* unsolicited event for HP jack sensing */
10132 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10133 				       unsigned int res)
10134 {
10135 	if ((res >> 26) != ALC_HP_EVENT)
10136 		return;
10137 	alc262_fujitsu_automute(codec, 1);
10138 }
10139 
10140 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10141 {
10142 	alc262_fujitsu_automute(codec, 1);
10143 }
10144 
10145 /* bind volumes of both NID 0x0c and 0x0d */
10146 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10147 	.ops = &snd_hda_bind_vol,
10148 	.values = {
10149 		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10150 		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10151 		0
10152 	},
10153 };
10154 
10155 /* mute/unmute internal speaker according to the hp jack and mute state */
10156 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10157 {
10158 	struct alc_spec *spec = codec->spec;
10159 	unsigned int mute;
10160 
10161 	if (force || !spec->sense_updated) {
10162 		unsigned int present_int_hp;
10163 		/* need to execute and sync at first */
10164 		snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10165 		present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10166 					AC_VERB_GET_PIN_SENSE, 0);
10167 		spec->jack_present = (present_int_hp & 0x80000000) != 0;
10168 		spec->sense_updated = 1;
10169 	}
10170 	if (spec->jack_present) {
10171 		/* mute internal speaker */
10172 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10173 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
10174 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10175 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
10176 	} else {
10177 		/* unmute internal speaker if necessary */
10178 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10179 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10180 					 HDA_AMP_MUTE, mute);
10181 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10182 					 HDA_AMP_MUTE, mute);
10183 	}
10184 }
10185 
10186 /* unsolicited event for HP jack sensing */
10187 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10188 				       unsigned int res)
10189 {
10190 	if ((res >> 26) != ALC_HP_EVENT)
10191 		return;
10192 	alc262_lenovo_3000_automute(codec, 1);
10193 }
10194 
10195 /* bind hp and internal speaker mute (with plug check) */
10196 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10197 					 struct snd_ctl_elem_value *ucontrol)
10198 {
10199 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10200 	long *valp = ucontrol->value.integer.value;
10201 	int change;
10202 
10203 	change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10204 						 HDA_AMP_MUTE,
10205 						 valp ? 0 : HDA_AMP_MUTE);
10206 	change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10207 						 HDA_AMP_MUTE,
10208 						 valp ? 0 : HDA_AMP_MUTE);
10209 
10210 	if (change)
10211 		alc262_fujitsu_automute(codec, 0);
10212 	return change;
10213 }
10214 
10215 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10216 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10217 	{
10218 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10219 		.name = "Master Playback Switch",
10220 		.info = snd_hda_mixer_amp_switch_info,
10221 		.get = snd_hda_mixer_amp_switch_get,
10222 		.put = alc262_fujitsu_master_sw_put,
10223 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10224 	},
10225 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10226 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10227 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10228 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10229 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10230 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10231 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10232 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10233 	{ } /* end */
10234 };
10235 
10236 /* bind hp and internal speaker mute (with plug check) */
10237 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10238 					 struct snd_ctl_elem_value *ucontrol)
10239 {
10240 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10241 	long *valp = ucontrol->value.integer.value;
10242 	int change;
10243 
10244 	change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10245 						 HDA_AMP_MUTE,
10246 						 valp ? 0 : HDA_AMP_MUTE);
10247 
10248 	if (change)
10249 		alc262_lenovo_3000_automute(codec, 0);
10250 	return change;
10251 }
10252 
10253 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10254 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10255 	{
10256 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10257 		.name = "Master Playback Switch",
10258 		.info = snd_hda_mixer_amp_switch_info,
10259 		.get = snd_hda_mixer_amp_switch_get,
10260 		.put = alc262_lenovo_3000_master_sw_put,
10261 		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10262 	},
10263 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10264 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10265 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10266 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10267 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10268 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10269 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10270 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10271 	{ } /* end */
10272 };
10273 
10274 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10275 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10276 	{
10277 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10278 		.name = "Master Playback Switch",
10279 		.info = snd_hda_mixer_amp_switch_info,
10280 		.get = snd_hda_mixer_amp_switch_get,
10281 		.put = alc262_sony_master_sw_put,
10282 		.private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10283 	},
10284 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10285 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10286 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10287 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10288 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10289 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10290 	{ } /* end */
10291 };
10292 
10293 /* additional init verbs for Benq laptops */
10294 static struct hda_verb alc262_EAPD_verbs[] = {
10295 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10296 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10297 	{}
10298 };
10299 
10300 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10301 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10302 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10303 
10304 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10305 	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10306 	{}
10307 };
10308 
10309 /* Samsung Q1 Ultra Vista model setup */
10310 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10311 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10312 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10313 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10314 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10315 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10316 	HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10317 	{ } /* end */
10318 };
10319 
10320 static struct hda_verb alc262_ultra_verbs[] = {
10321 	/* output mixer */
10322 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10323 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10324 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10325 	/* speaker */
10326 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10327 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10328 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10329 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10330 	/* HP */
10331 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10332 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10333 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10334 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10335 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10336 	/* internal mic */
10337 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10338 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10339 	/* ADC, choose mic */
10340 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10341 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10342 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10343 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10344 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10345 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10346 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10347 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10348 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10349 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10350 	{}
10351 };
10352 
10353 /* mute/unmute internal speaker according to the hp jack and mute state */
10354 static void alc262_ultra_automute(struct hda_codec *codec)
10355 {
10356 	struct alc_spec *spec = codec->spec;
10357 	unsigned int mute;
10358 
10359 	mute = 0;
10360 	/* auto-mute only when HP is used as HP */
10361 	if (!spec->cur_mux[0]) {
10362 		unsigned int present;
10363 		/* need to execute and sync at first */
10364 		snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10365 		present = snd_hda_codec_read(codec, 0x15, 0,
10366 					     AC_VERB_GET_PIN_SENSE, 0);
10367 		spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10368 		if (spec->jack_present)
10369 			mute = HDA_AMP_MUTE;
10370 	}
10371 	/* mute/unmute internal speaker */
10372 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10373 				 HDA_AMP_MUTE, mute);
10374 	/* mute/unmute HP */
10375 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10376 				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10377 }
10378 
10379 /* unsolicited event for HP jack sensing */
10380 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10381 				       unsigned int res)
10382 {
10383 	if ((res >> 26) != ALC880_HP_EVENT)
10384 		return;
10385 	alc262_ultra_automute(codec);
10386 }
10387 
10388 static struct hda_input_mux alc262_ultra_capture_source = {
10389 	.num_items = 2,
10390 	.items = {
10391 		{ "Mic", 0x1 },
10392 		{ "Headphone", 0x7 },
10393 	},
10394 };
10395 
10396 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10397 				     struct snd_ctl_elem_value *ucontrol)
10398 {
10399 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10400 	struct alc_spec *spec = codec->spec;
10401 	int ret;
10402 
10403 	ret = alc_mux_enum_put(kcontrol, ucontrol);
10404 	if (!ret)
10405 		return 0;
10406 	/* reprogram the HP pin as mic or HP according to the input source */
10407 	snd_hda_codec_write_cache(codec, 0x15, 0,
10408 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10409 				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10410 	alc262_ultra_automute(codec); /* mute/unmute HP */
10411 	return ret;
10412 }
10413 
10414 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10415 	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10416 	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10417 	{
10418 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10419 		.name = "Capture Source",
10420 		.info = alc_mux_enum_info,
10421 		.get = alc_mux_enum_get,
10422 		.put = alc262_ultra_mux_enum_put,
10423 	},
10424 	{ } /* end */
10425 };
10426 
10427 /* add playback controls from the parsed DAC table */
10428 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10429 					     const struct auto_pin_cfg *cfg)
10430 {
10431 	hda_nid_t nid;
10432 	int err;
10433 
10434 	spec->multiout.num_dacs = 1;	/* only use one dac */
10435 	spec->multiout.dac_nids = spec->private_dac_nids;
10436 	spec->multiout.dac_nids[0] = 2;
10437 
10438 	nid = cfg->line_out_pins[0];
10439 	if (nid) {
10440 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
10441 				  "Front Playback Volume",
10442 				  HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10443 		if (err < 0)
10444 			return err;
10445 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10446 				  "Front Playback Switch",
10447 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10448 		if (err < 0)
10449 			return err;
10450 	}
10451 
10452 	nid = cfg->speaker_pins[0];
10453 	if (nid) {
10454 		if (nid == 0x16) {
10455 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
10456 					  "Speaker Playback Volume",
10457 					  HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10458 							      HDA_OUTPUT));
10459 			if (err < 0)
10460 				return err;
10461 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10462 					  "Speaker Playback Switch",
10463 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10464 							      HDA_OUTPUT));
10465 			if (err < 0)
10466 				return err;
10467 		} else {
10468 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10469 					  "Speaker Playback Switch",
10470 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10471 							      HDA_OUTPUT));
10472 			if (err < 0)
10473 				return err;
10474 		}
10475 	}
10476 	nid = cfg->hp_pins[0];
10477 	if (nid) {
10478 		/* spec->multiout.hp_nid = 2; */
10479 		if (nid == 0x16) {
10480 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
10481 					  "Headphone Playback Volume",
10482 					  HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10483 							      HDA_OUTPUT));
10484 			if (err < 0)
10485 				return err;
10486 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10487 					  "Headphone Playback Switch",
10488 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10489 							      HDA_OUTPUT));
10490 			if (err < 0)
10491 				return err;
10492 		} else {
10493 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10494 					  "Headphone Playback Switch",
10495 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10496 							      HDA_OUTPUT));
10497 			if (err < 0)
10498 				return err;
10499 		}
10500 	}
10501 	return 0;
10502 }
10503 
10504 /* identical with ALC880 */
10505 #define alc262_auto_create_analog_input_ctls \
10506 	alc880_auto_create_analog_input_ctls
10507 
10508 /*
10509  * generic initialization of ADC, input mixers and output mixers
10510  */
10511 static struct hda_verb alc262_volume_init_verbs[] = {
10512 	/*
10513 	 * Unmute ADC0-2 and set the default input to mic-in
10514 	 */
10515 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10516 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10517 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10518 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10519 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10520 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10521 
10522 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10523 	 * mixer widget
10524 	 * Note: PASD motherboards uses the Line In 2 as the input for
10525 	 * front panel mic (mic 2)
10526 	 */
10527 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10528 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10529 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10530 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10531 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10532 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10533 
10534 	/*
10535 	 * Set up output mixers (0x0c - 0x0f)
10536 	 */
10537 	/* set vol=0 to output mixers */
10538 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10539 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10540 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10541 
10542 	/* set up input amps for analog loopback */
10543 	/* Amp Indices: DAC = 0, mixer = 1 */
10544 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10545 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10546 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10547 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10548 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10549 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10550 
10551 	/* FIXME: use matrix-type input source selection */
10552 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10553 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10554 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10555 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10556 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10557 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10558 	/* Input mixer2 */
10559 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10560 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10561 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10562 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10563 	/* Input mixer3 */
10564 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10565 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10566 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10567 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10568 
10569 	{ }
10570 };
10571 
10572 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10573 	/*
10574 	 * Unmute ADC0-2 and set the default input to mic-in
10575 	 */
10576 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10577 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10578 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10579 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10580 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10581 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10582 
10583 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10584 	 * mixer widget
10585 	 * Note: PASD motherboards uses the Line In 2 as the input for
10586 	 * front panel mic (mic 2)
10587 	 */
10588 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10589 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10590 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10591 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10592 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10593 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10594 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10595         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10596 
10597 	/*
10598 	 * Set up output mixers (0x0c - 0x0e)
10599 	 */
10600 	/* set vol=0 to output mixers */
10601 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10602 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10603 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10604 
10605 	/* set up input amps for analog loopback */
10606 	/* Amp Indices: DAC = 0, mixer = 1 */
10607 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10608 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10609 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10610 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10611 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10612 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10613 
10614 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10615 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10616 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10617 
10618 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10619 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10620 
10621 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10622 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10623 
10624 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10625 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10626         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10627 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10628 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10629 
10630 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10631 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10632         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10633 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10634 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10635 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10636 
10637 
10638 	/* FIXME: use matrix-type input source selection */
10639 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10640 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10641 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10642 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10643 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10644 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10645 	/* Input mixer2 */
10646 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10647 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10648 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10649 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10650 	/* Input mixer3 */
10651 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10652 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10653 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10654 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10655 
10656 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10657 
10658 	{ }
10659 };
10660 
10661 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10662 	/*
10663 	 * Unmute ADC0-2 and set the default input to mic-in
10664 	 */
10665 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10666 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10667 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10668 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10669 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10670 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10671 
10672 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10673 	 * mixer widget
10674 	 * Note: PASD motherboards uses the Line In 2 as the input for front
10675 	 * panel mic (mic 2)
10676 	 */
10677 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10678 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10679 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10680 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10681 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10682 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10683 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10684 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10685 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10686 	/*
10687 	 * Set up output mixers (0x0c - 0x0e)
10688 	 */
10689 	/* set vol=0 to output mixers */
10690 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10691 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10692 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10693 
10694 	/* set up input amps for analog loopback */
10695 	/* Amp Indices: DAC = 0, mixer = 1 */
10696 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10697 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10698 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10699 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10700 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10701 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10702 
10703 
10704 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
10705 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
10706 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
10707 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
10708 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
10709 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
10710 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
10711 
10712 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10713 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10714 
10715 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10716 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10717 
10718 	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10719 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10720 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10721 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10722 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10723 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10724 
10725 	/* FIXME: use matrix-type input source selection */
10726 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10727 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10728 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10729 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10730 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10731 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10732 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10733         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10734 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10735 	/* Input mixer2 */
10736 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10737 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10738 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10739 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10740 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10741         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10742 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10743 	/* Input mixer3 */
10744 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10745 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10746 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10747 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10748 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10749         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10750 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10751 
10752 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10753 
10754 	{ }
10755 };
10756 
10757 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10758 
10759 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
10760 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10761 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10762 
10763 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
10764 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
10765 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10766 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10767 
10768 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
10769 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10770 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10771 	{}
10772 };
10773 
10774 
10775 #ifdef CONFIG_SND_HDA_POWER_SAVE
10776 #define alc262_loopbacks	alc880_loopbacks
10777 #endif
10778 
10779 /* pcm configuration: identiacal with ALC880 */
10780 #define alc262_pcm_analog_playback	alc880_pcm_analog_playback
10781 #define alc262_pcm_analog_capture	alc880_pcm_analog_capture
10782 #define alc262_pcm_digital_playback	alc880_pcm_digital_playback
10783 #define alc262_pcm_digital_capture	alc880_pcm_digital_capture
10784 
10785 /*
10786  * BIOS auto configuration
10787  */
10788 static int alc262_parse_auto_config(struct hda_codec *codec)
10789 {
10790 	struct alc_spec *spec = codec->spec;
10791 	int err;
10792 	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10793 
10794 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10795 					   alc262_ignore);
10796 	if (err < 0)
10797 		return err;
10798 	if (!spec->autocfg.line_outs) {
10799 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10800 			spec->multiout.max_channels = 2;
10801 			spec->no_analog = 1;
10802 			goto dig_only;
10803 		}
10804 		return 0; /* can't find valid BIOS pin config */
10805 	}
10806 	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10807 	if (err < 0)
10808 		return err;
10809 	err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10810 	if (err < 0)
10811 		return err;
10812 
10813 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10814 
10815  dig_only:
10816 	if (spec->autocfg.dig_outs) {
10817 		spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10818 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
10819 	}
10820 	if (spec->autocfg.dig_in_pin)
10821 		spec->dig_in_nid = ALC262_DIGIN_NID;
10822 
10823 	if (spec->kctls.list)
10824 		add_mixer(spec, spec->kctls.list);
10825 
10826 	add_verb(spec, alc262_volume_init_verbs);
10827 	spec->num_mux_defs = 1;
10828 	spec->input_mux = &spec->private_imux[0];
10829 
10830 	err = alc_auto_add_mic_boost(codec);
10831 	if (err < 0)
10832 		return err;
10833 
10834 	return 1;
10835 }
10836 
10837 #define alc262_auto_init_multi_out	alc882_auto_init_multi_out
10838 #define alc262_auto_init_hp_out		alc882_auto_init_hp_out
10839 #define alc262_auto_init_analog_input	alc882_auto_init_analog_input
10840 #define alc262_auto_init_input_src	alc882_auto_init_input_src
10841 
10842 
10843 /* init callback for auto-configuration model -- overriding the default init */
10844 static void alc262_auto_init(struct hda_codec *codec)
10845 {
10846 	struct alc_spec *spec = codec->spec;
10847 	alc262_auto_init_multi_out(codec);
10848 	alc262_auto_init_hp_out(codec);
10849 	alc262_auto_init_analog_input(codec);
10850 	alc262_auto_init_input_src(codec);
10851 	if (spec->unsol_event)
10852 		alc_inithook(codec);
10853 }
10854 
10855 /*
10856  * configuration and preset
10857  */
10858 static const char *alc262_models[ALC262_MODEL_LAST] = {
10859 	[ALC262_BASIC]		= "basic",
10860 	[ALC262_HIPPO]		= "hippo",
10861 	[ALC262_HIPPO_1]	= "hippo_1",
10862 	[ALC262_FUJITSU]	= "fujitsu",
10863 	[ALC262_HP_BPC]		= "hp-bpc",
10864 	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10865 	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
10866 	[ALC262_HP_RP5700]	= "hp-rp5700",
10867 	[ALC262_BENQ_ED8]	= "benq",
10868 	[ALC262_BENQ_T31]	= "benq-t31",
10869 	[ALC262_SONY_ASSAMD]	= "sony-assamd",
10870 	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
10871 	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
10872 	[ALC262_ULTRA]		= "ultra",
10873 	[ALC262_LENOVO_3000]	= "lenovo-3000",
10874 	[ALC262_NEC]		= "nec",
10875 	[ALC262_TYAN]		= "tyan",
10876 	[ALC262_AUTO]		= "auto",
10877 };
10878 
10879 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10880 	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10881 	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10882 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10883 			   ALC262_HP_BPC),
10884 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10885 			   ALC262_HP_BPC),
10886 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10887 			   ALC262_HP_BPC),
10888 	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10889 	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10890 	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10891 	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10892 	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10893 	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10894 	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10895 	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10896 	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10897 	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10898 	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10899 	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10900 		      ALC262_HP_TC_T5735),
10901 	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10902 	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10903 	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10904 	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10905 	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10906 	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10907 			   ALC262_SONY_ASSAMD),
10908 	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10909 		      ALC262_TOSHIBA_RX1),
10910 	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10911 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10912 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10913 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10914 	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10915 			   ALC262_ULTRA),
10916 	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10917 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10918 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10919 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10920 	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10921 	{}
10922 };
10923 
10924 static struct alc_config_preset alc262_presets[] = {
10925 	[ALC262_BASIC] = {
10926 		.mixers = { alc262_base_mixer },
10927 		.init_verbs = { alc262_init_verbs },
10928 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10929 		.dac_nids = alc262_dac_nids,
10930 		.hp_nid = 0x03,
10931 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10932 		.channel_mode = alc262_modes,
10933 		.input_mux = &alc262_capture_source,
10934 	},
10935 	[ALC262_HIPPO] = {
10936 		.mixers = { alc262_base_mixer },
10937 		.init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10938 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10939 		.dac_nids = alc262_dac_nids,
10940 		.hp_nid = 0x03,
10941 		.dig_out_nid = ALC262_DIGOUT_NID,
10942 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10943 		.channel_mode = alc262_modes,
10944 		.input_mux = &alc262_capture_source,
10945 		.unsol_event = alc262_hippo_unsol_event,
10946 		.init_hook = alc262_hippo_automute,
10947 	},
10948 	[ALC262_HIPPO_1] = {
10949 		.mixers = { alc262_hippo1_mixer },
10950 		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10951 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10952 		.dac_nids = alc262_dac_nids,
10953 		.hp_nid = 0x02,
10954 		.dig_out_nid = ALC262_DIGOUT_NID,
10955 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10956 		.channel_mode = alc262_modes,
10957 		.input_mux = &alc262_capture_source,
10958 		.unsol_event = alc262_hippo1_unsol_event,
10959 		.init_hook = alc262_hippo1_automute,
10960 	},
10961 	[ALC262_FUJITSU] = {
10962 		.mixers = { alc262_fujitsu_mixer },
10963 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10964 				alc262_fujitsu_unsol_verbs },
10965 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10966 		.dac_nids = alc262_dac_nids,
10967 		.hp_nid = 0x03,
10968 		.dig_out_nid = ALC262_DIGOUT_NID,
10969 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10970 		.channel_mode = alc262_modes,
10971 		.input_mux = &alc262_fujitsu_capture_source,
10972 		.unsol_event = alc262_fujitsu_unsol_event,
10973 		.init_hook = alc262_fujitsu_init_hook,
10974 	},
10975 	[ALC262_HP_BPC] = {
10976 		.mixers = { alc262_HP_BPC_mixer },
10977 		.init_verbs = { alc262_HP_BPC_init_verbs },
10978 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10979 		.dac_nids = alc262_dac_nids,
10980 		.hp_nid = 0x03,
10981 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10982 		.channel_mode = alc262_modes,
10983 		.input_mux = &alc262_HP_capture_source,
10984 		.unsol_event = alc262_hp_bpc_unsol_event,
10985 		.init_hook = alc262_hp_bpc_automute,
10986 	},
10987 	[ALC262_HP_BPC_D7000_WF] = {
10988 		.mixers = { alc262_HP_BPC_WildWest_mixer },
10989 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10990 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10991 		.dac_nids = alc262_dac_nids,
10992 		.hp_nid = 0x03,
10993 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10994 		.channel_mode = alc262_modes,
10995 		.input_mux = &alc262_HP_D7000_capture_source,
10996 		.unsol_event = alc262_hp_wildwest_unsol_event,
10997 		.init_hook = alc262_hp_wildwest_automute,
10998 	},
10999 	[ALC262_HP_BPC_D7000_WL] = {
11000 		.mixers = { alc262_HP_BPC_WildWest_mixer,
11001 			    alc262_HP_BPC_WildWest_option_mixer },
11002 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11003 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11004 		.dac_nids = alc262_dac_nids,
11005 		.hp_nid = 0x03,
11006 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11007 		.channel_mode = alc262_modes,
11008 		.input_mux = &alc262_HP_D7000_capture_source,
11009 		.unsol_event = alc262_hp_wildwest_unsol_event,
11010 		.init_hook = alc262_hp_wildwest_automute,
11011 	},
11012 	[ALC262_HP_TC_T5735] = {
11013 		.mixers = { alc262_hp_t5735_mixer },
11014 		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11015 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11016 		.dac_nids = alc262_dac_nids,
11017 		.hp_nid = 0x03,
11018 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11019 		.channel_mode = alc262_modes,
11020 		.input_mux = &alc262_capture_source,
11021 		.unsol_event = alc262_hp_t5735_unsol_event,
11022 		.init_hook = alc262_hp_t5735_init_hook,
11023 	},
11024 	[ALC262_HP_RP5700] = {
11025 		.mixers = { alc262_hp_rp5700_mixer },
11026 		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11027 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11028 		.dac_nids = alc262_dac_nids,
11029 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11030 		.channel_mode = alc262_modes,
11031 		.input_mux = &alc262_hp_rp5700_capture_source,
11032         },
11033 	[ALC262_BENQ_ED8] = {
11034 		.mixers = { alc262_base_mixer },
11035 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11036 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11037 		.dac_nids = alc262_dac_nids,
11038 		.hp_nid = 0x03,
11039 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11040 		.channel_mode = alc262_modes,
11041 		.input_mux = &alc262_capture_source,
11042 	},
11043 	[ALC262_SONY_ASSAMD] = {
11044 		.mixers = { alc262_sony_mixer },
11045 		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11046 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11047 		.dac_nids = alc262_dac_nids,
11048 		.hp_nid = 0x02,
11049 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11050 		.channel_mode = alc262_modes,
11051 		.input_mux = &alc262_capture_source,
11052 		.unsol_event = alc262_hippo_unsol_event,
11053 		.init_hook = alc262_hippo_automute,
11054 	},
11055 	[ALC262_BENQ_T31] = {
11056 		.mixers = { alc262_benq_t31_mixer },
11057 		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11058 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11059 		.dac_nids = alc262_dac_nids,
11060 		.hp_nid = 0x03,
11061 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11062 		.channel_mode = alc262_modes,
11063 		.input_mux = &alc262_capture_source,
11064 		.unsol_event = alc262_hippo_unsol_event,
11065 		.init_hook = alc262_hippo_automute,
11066 	},
11067 	[ALC262_ULTRA] = {
11068 		.mixers = { alc262_ultra_mixer },
11069 		.cap_mixer = alc262_ultra_capture_mixer,
11070 		.init_verbs = { alc262_ultra_verbs },
11071 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11072 		.dac_nids = alc262_dac_nids,
11073 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11074 		.channel_mode = alc262_modes,
11075 		.input_mux = &alc262_ultra_capture_source,
11076 		.adc_nids = alc262_adc_nids, /* ADC0 */
11077 		.capsrc_nids = alc262_capsrc_nids,
11078 		.num_adc_nids = 1, /* single ADC */
11079 		.unsol_event = alc262_ultra_unsol_event,
11080 		.init_hook = alc262_ultra_automute,
11081 	},
11082 	[ALC262_LENOVO_3000] = {
11083 		.mixers = { alc262_lenovo_3000_mixer },
11084 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11085 				alc262_lenovo_3000_unsol_verbs },
11086 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11087 		.dac_nids = alc262_dac_nids,
11088 		.hp_nid = 0x03,
11089 		.dig_out_nid = ALC262_DIGOUT_NID,
11090 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11091 		.channel_mode = alc262_modes,
11092 		.input_mux = &alc262_fujitsu_capture_source,
11093 		.unsol_event = alc262_lenovo_3000_unsol_event,
11094 	},
11095 	[ALC262_NEC] = {
11096 		.mixers = { alc262_nec_mixer },
11097 		.init_verbs = { alc262_nec_verbs },
11098 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11099 		.dac_nids = alc262_dac_nids,
11100 		.hp_nid = 0x03,
11101 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11102 		.channel_mode = alc262_modes,
11103 		.input_mux = &alc262_capture_source,
11104 	},
11105 	[ALC262_TOSHIBA_S06] = {
11106 		.mixers = { alc262_toshiba_s06_mixer },
11107 		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11108 							alc262_eapd_verbs },
11109 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11110 		.capsrc_nids = alc262_dmic_capsrc_nids,
11111 		.dac_nids = alc262_dac_nids,
11112 		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11113 		.dig_out_nid = ALC262_DIGOUT_NID,
11114 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11115 		.channel_mode = alc262_modes,
11116 		.input_mux = &alc262_dmic_capture_source,
11117 		.unsol_event = alc262_toshiba_s06_unsol_event,
11118 		.init_hook = alc262_toshiba_s06_init_hook,
11119 	},
11120 	[ALC262_TOSHIBA_RX1] = {
11121 		.mixers = { alc262_toshiba_rx1_mixer },
11122 		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11123 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11124 		.dac_nids = alc262_dac_nids,
11125 		.hp_nid = 0x03,
11126 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11127 		.channel_mode = alc262_modes,
11128 		.input_mux = &alc262_capture_source,
11129 		.unsol_event = alc262_hippo_unsol_event,
11130 		.init_hook = alc262_hippo_automute,
11131 	},
11132 	[ALC262_TYAN] = {
11133 		.mixers = { alc262_tyan_mixer },
11134 		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11135 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11136 		.dac_nids = alc262_dac_nids,
11137 		.hp_nid = 0x02,
11138 		.dig_out_nid = ALC262_DIGOUT_NID,
11139 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11140 		.channel_mode = alc262_modes,
11141 		.input_mux = &alc262_capture_source,
11142 		.unsol_event = alc262_tyan_unsol_event,
11143 		.init_hook = alc262_tyan_automute,
11144 	},
11145 };
11146 
11147 static int patch_alc262(struct hda_codec *codec)
11148 {
11149 	struct alc_spec *spec;
11150 	int board_config;
11151 	int err;
11152 
11153 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11154 	if (spec == NULL)
11155 		return -ENOMEM;
11156 
11157 	codec->spec = spec;
11158 #if 0
11159 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11160 	 * under-run
11161 	 */
11162 	{
11163 	int tmp;
11164 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11165 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11166 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11167 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11168 	}
11169 #endif
11170 
11171 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11172 
11173 	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11174 						  alc262_models,
11175 						  alc262_cfg_tbl);
11176 
11177 	if (board_config < 0) {
11178 		printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
11179 		       "trying auto-probe from BIOS...\n");
11180 		board_config = ALC262_AUTO;
11181 	}
11182 
11183 	if (board_config == ALC262_AUTO) {
11184 		/* automatic parse from the BIOS config */
11185 		err = alc262_parse_auto_config(codec);
11186 		if (err < 0) {
11187 			alc_free(codec);
11188 			return err;
11189 		} else if (!err) {
11190 			printk(KERN_INFO
11191 			       "hda_codec: Cannot set up configuration "
11192 			       "from BIOS.  Using base mode...\n");
11193 			board_config = ALC262_BASIC;
11194 		}
11195 	}
11196 
11197 	if (!spec->no_analog) {
11198 		err = snd_hda_attach_beep_device(codec, 0x1);
11199 		if (err < 0) {
11200 			alc_free(codec);
11201 			return err;
11202 		}
11203 	}
11204 
11205 	if (board_config != ALC262_AUTO)
11206 		setup_preset(spec, &alc262_presets[board_config]);
11207 
11208 	spec->stream_name_analog = "ALC262 Analog";
11209 	spec->stream_analog_playback = &alc262_pcm_analog_playback;
11210 	spec->stream_analog_capture = &alc262_pcm_analog_capture;
11211 
11212 	spec->stream_name_digital = "ALC262 Digital";
11213 	spec->stream_digital_playback = &alc262_pcm_digital_playback;
11214 	spec->stream_digital_capture = &alc262_pcm_digital_capture;
11215 
11216 	spec->capture_style = CAPT_MIX;
11217 	if (!spec->adc_nids && spec->input_mux) {
11218 		/* check whether NID 0x07 is valid */
11219 		unsigned int wcap = get_wcaps(codec, 0x07);
11220 
11221 		/* get type */
11222 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11223 		if (wcap != AC_WID_AUD_IN) {
11224 			spec->adc_nids = alc262_adc_nids_alt;
11225 			spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11226 			spec->capsrc_nids = alc262_capsrc_nids_alt;
11227 		} else {
11228 			spec->adc_nids = alc262_adc_nids;
11229 			spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11230 			spec->capsrc_nids = alc262_capsrc_nids;
11231 		}
11232 	}
11233 	if (!spec->cap_mixer && !spec->no_analog)
11234 		set_capture_mixer(spec);
11235 	if (!spec->no_analog)
11236 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11237 
11238 	spec->vmaster_nid = 0x0c;
11239 
11240 	codec->patch_ops = alc_patch_ops;
11241 	if (board_config == ALC262_AUTO)
11242 		spec->init_hook = alc262_auto_init;
11243 #ifdef CONFIG_SND_HDA_POWER_SAVE
11244 	if (!spec->loopback.amplist)
11245 		spec->loopback.amplist = alc262_loopbacks;
11246 #endif
11247 	codec->proc_widget_hook = print_realtek_coef;
11248 
11249 	return 0;
11250 }
11251 
11252 /*
11253  *  ALC268 channel source setting (2 channel)
11254  */
11255 #define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
11256 #define alc268_modes		alc260_modes
11257 
11258 static hda_nid_t alc268_dac_nids[2] = {
11259 	/* front, hp */
11260 	0x02, 0x03
11261 };
11262 
11263 static hda_nid_t alc268_adc_nids[2] = {
11264 	/* ADC0-1 */
11265 	0x08, 0x07
11266 };
11267 
11268 static hda_nid_t alc268_adc_nids_alt[1] = {
11269 	/* ADC0 */
11270 	0x08
11271 };
11272 
11273 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11274 
11275 static struct snd_kcontrol_new alc268_base_mixer[] = {
11276 	/* output mixer control */
11277 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11278 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11279 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11280 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11281 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11282 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11283 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11284 	{ }
11285 };
11286 
11287 /* bind Beep switches of both NID 0x0f and 0x10 */
11288 static struct hda_bind_ctls alc268_bind_beep_sw = {
11289 	.ops = &snd_hda_bind_sw,
11290 	.values = {
11291 		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11292 		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11293 		0
11294 	},
11295 };
11296 
11297 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11298 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11299 	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11300 	{ }
11301 };
11302 
11303 static struct hda_verb alc268_eapd_verbs[] = {
11304 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11305 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11306 	{ }
11307 };
11308 
11309 /* Toshiba specific */
11310 #define alc268_toshiba_automute	alc262_hippo_automute
11311 
11312 static struct hda_verb alc268_toshiba_verbs[] = {
11313 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11314 	{ } /* end */
11315 };
11316 
11317 static struct hda_input_mux alc268_acer_lc_capture_source = {
11318 	.num_items = 2,
11319 	.items = {
11320 		{ "i-Mic", 0x6 },
11321 		{ "E-Mic", 0x0 },
11322 	},
11323 };
11324 
11325 /* Acer specific */
11326 /* bind volumes of both NID 0x02 and 0x03 */
11327 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11328 	.ops = &snd_hda_bind_vol,
11329 	.values = {
11330 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11331 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11332 		0
11333 	},
11334 };
11335 
11336 /* mute/unmute internal speaker according to the hp jack and mute state */
11337 static void alc268_acer_automute(struct hda_codec *codec, int force)
11338 {
11339 	struct alc_spec *spec = codec->spec;
11340 	unsigned int mute;
11341 
11342 	if (force || !spec->sense_updated) {
11343 		unsigned int present;
11344 		present = snd_hda_codec_read(codec, 0x14, 0,
11345 				    	 AC_VERB_GET_PIN_SENSE, 0);
11346 		spec->jack_present = (present & 0x80000000) != 0;
11347 		spec->sense_updated = 1;
11348 	}
11349 	if (spec->jack_present)
11350 		mute = HDA_AMP_MUTE; /* mute internal speaker */
11351 	else /* unmute internal speaker if necessary */
11352 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11353 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11354 				 HDA_AMP_MUTE, mute);
11355 }
11356 
11357 
11358 /* bind hp and internal speaker mute (with plug check) */
11359 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11360 				     struct snd_ctl_elem_value *ucontrol)
11361 {
11362 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11363 	long *valp = ucontrol->value.integer.value;
11364 	int change;
11365 
11366 	change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11367 					  HDA_AMP_MUTE,
11368 					  valp[0] ? 0 : HDA_AMP_MUTE);
11369 	change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11370 					   HDA_AMP_MUTE,
11371 					   valp[1] ? 0 : HDA_AMP_MUTE);
11372 	if (change)
11373 		alc268_acer_automute(codec, 0);
11374 	return change;
11375 }
11376 
11377 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11378 	/* output mixer control */
11379 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11380 	{
11381 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11382 		.name = "Master Playback Switch",
11383 		.info = snd_hda_mixer_amp_switch_info,
11384 		.get = snd_hda_mixer_amp_switch_get,
11385 		.put = alc268_acer_master_sw_put,
11386 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11387 	},
11388 	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11389 	{ }
11390 };
11391 
11392 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11393 	/* output mixer control */
11394 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11395 	{
11396 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11397 		.name = "Master Playback Switch",
11398 		.info = snd_hda_mixer_amp_switch_info,
11399 		.get = snd_hda_mixer_amp_switch_get,
11400 		.put = alc268_acer_master_sw_put,
11401 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11402 	},
11403 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11404 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11405 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11406 	{ }
11407 };
11408 
11409 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11410 	/* output mixer control */
11411 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11412 	{
11413 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11414 		.name = "Master Playback Switch",
11415 		.info = snd_hda_mixer_amp_switch_info,
11416 		.get = snd_hda_mixer_amp_switch_get,
11417 		.put = alc268_acer_master_sw_put,
11418 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11419 	},
11420 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11421 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11422 	{ }
11423 };
11424 
11425 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11426 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11427 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11428 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11429 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11430 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11431 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11432 	{ }
11433 };
11434 
11435 static struct hda_verb alc268_acer_verbs[] = {
11436 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11437 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11438 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11439 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11440 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11441 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11442 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11443 	{ }
11444 };
11445 
11446 /* unsolicited event for HP jack sensing */
11447 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11448 				       unsigned int res)
11449 {
11450 	if ((res >> 26) != ALC880_HP_EVENT)
11451 		return;
11452 	alc268_toshiba_automute(codec);
11453 }
11454 
11455 static void alc268_acer_unsol_event(struct hda_codec *codec,
11456 				       unsigned int res)
11457 {
11458 	if ((res >> 26) != ALC880_HP_EVENT)
11459 		return;
11460 	alc268_acer_automute(codec, 1);
11461 }
11462 
11463 static void alc268_acer_init_hook(struct hda_codec *codec)
11464 {
11465 	alc268_acer_automute(codec, 1);
11466 }
11467 
11468 /* toggle speaker-output according to the hp-jack state */
11469 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11470 {
11471 	unsigned int present;
11472 	unsigned char bits;
11473 
11474 	present = snd_hda_codec_read(codec, 0x15, 0,
11475 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11476 	bits = present ? AMP_IN_MUTE(0) : 0;
11477 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11478 				AMP_IN_MUTE(0), bits);
11479 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11480 				AMP_IN_MUTE(0), bits);
11481 }
11482 
11483 
11484 static void alc268_acer_mic_automute(struct hda_codec *codec)
11485 {
11486 	unsigned int present;
11487 
11488 	present = snd_hda_codec_read(codec, 0x18, 0,
11489 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11490 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11491 			    present ? 0x0 : 0x6);
11492 }
11493 
11494 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11495 				    unsigned int res)
11496 {
11497 	if ((res >> 26) == ALC880_HP_EVENT)
11498 		alc268_aspire_one_speaker_automute(codec);
11499 	if ((res >> 26) == ALC880_MIC_EVENT)
11500 		alc268_acer_mic_automute(codec);
11501 }
11502 
11503 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11504 {
11505 	alc268_aspire_one_speaker_automute(codec);
11506 	alc268_acer_mic_automute(codec);
11507 }
11508 
11509 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11510 	/* output mixer control */
11511 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11512 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11513 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11514 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11515 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11516 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11517 	{ }
11518 };
11519 
11520 static struct hda_verb alc268_dell_verbs[] = {
11521 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11522 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11523 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11524 	{ }
11525 };
11526 
11527 /* mute/unmute internal speaker according to the hp jack and mute state */
11528 static void alc268_dell_automute(struct hda_codec *codec)
11529 {
11530 	unsigned int present;
11531 	unsigned int mute;
11532 
11533 	present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11534 	if (present & 0x80000000)
11535 		mute = HDA_AMP_MUTE;
11536 	else
11537 		mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11538 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11539 				 HDA_AMP_MUTE, mute);
11540 }
11541 
11542 static void alc268_dell_unsol_event(struct hda_codec *codec,
11543 				    unsigned int res)
11544 {
11545 	if ((res >> 26) != ALC880_HP_EVENT)
11546 		return;
11547 	alc268_dell_automute(codec);
11548 }
11549 
11550 #define alc268_dell_init_hook	alc268_dell_automute
11551 
11552 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11553 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11554 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11555 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11556 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11557 	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11558 	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11559 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11560 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11561 	{ }
11562 };
11563 
11564 static struct hda_verb alc267_quanta_il1_verbs[] = {
11565 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11566 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11567 	{ }
11568 };
11569 
11570 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11571 {
11572 	unsigned int present;
11573 
11574 	present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11575 		& AC_PINSENSE_PRESENCE;
11576 	snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11577 			    present ? 0 : PIN_OUT);
11578 }
11579 
11580 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11581 {
11582 	unsigned int present;
11583 
11584 	present = snd_hda_codec_read(codec, 0x18, 0,
11585 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11586 	snd_hda_codec_write(codec, 0x23, 0,
11587 			    AC_VERB_SET_CONNECT_SEL,
11588 			    present ? 0x00 : 0x01);
11589 }
11590 
11591 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11592 {
11593 	alc267_quanta_il1_hp_automute(codec);
11594 	alc267_quanta_il1_mic_automute(codec);
11595 }
11596 
11597 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11598 					   unsigned int res)
11599 {
11600 	switch (res >> 26) {
11601 	case ALC880_HP_EVENT:
11602 		alc267_quanta_il1_hp_automute(codec);
11603 		break;
11604 	case ALC880_MIC_EVENT:
11605 		alc267_quanta_il1_mic_automute(codec);
11606 		break;
11607 	}
11608 }
11609 
11610 /*
11611  * generic initialization of ADC, input mixers and output mixers
11612  */
11613 static struct hda_verb alc268_base_init_verbs[] = {
11614 	/* Unmute DAC0-1 and set vol = 0 */
11615 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11616 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11617 
11618 	/*
11619 	 * Set up output mixers (0x0c - 0x0e)
11620 	 */
11621 	/* set vol=0 to output mixers */
11622 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11623         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11624 
11625 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11626 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11627 
11628 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11629 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11630 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11631 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11632 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11633 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11634 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11635 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11636 
11637 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11638 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11639 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11640 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11641 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11642 
11643 	/* set PCBEEP vol = 0, mute connections */
11644 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11645 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11646 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11647 
11648 	/* Unmute Selector 23h,24h and set the default input to mic-in */
11649 
11650 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11651 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11652 	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11653 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11654 
11655 	{ }
11656 };
11657 
11658 /*
11659  * generic initialization of ADC, input mixers and output mixers
11660  */
11661 static struct hda_verb alc268_volume_init_verbs[] = {
11662 	/* set output DAC */
11663 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11664 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11665 
11666 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11667 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11668 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11669 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11670 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11671 
11672 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11673 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11674 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11675 
11676 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11677 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11678 
11679 	/* set PCBEEP vol = 0, mute connections */
11680 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11681 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11682 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11683 
11684 	{ }
11685 };
11686 
11687 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11688 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11689 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11690 	{
11691 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11692 		/* The multiple "Capture Source" controls confuse alsamixer
11693 		 * So call somewhat different..
11694 		 */
11695 		/* .name = "Capture Source", */
11696 		.name = "Input Source",
11697 		.count = 1,
11698 		.info = alc_mux_enum_info,
11699 		.get = alc_mux_enum_get,
11700 		.put = alc_mux_enum_put,
11701 	},
11702 	{ } /* end */
11703 };
11704 
11705 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11706 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11707 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11708 	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11709 	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11710 	{
11711 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11712 		/* The multiple "Capture Source" controls confuse alsamixer
11713 		 * So call somewhat different..
11714 		 */
11715 		/* .name = "Capture Source", */
11716 		.name = "Input Source",
11717 		.count = 2,
11718 		.info = alc_mux_enum_info,
11719 		.get = alc_mux_enum_get,
11720 		.put = alc_mux_enum_put,
11721 	},
11722 	{ } /* end */
11723 };
11724 
11725 static struct hda_input_mux alc268_capture_source = {
11726 	.num_items = 4,
11727 	.items = {
11728 		{ "Mic", 0x0 },
11729 		{ "Front Mic", 0x1 },
11730 		{ "Line", 0x2 },
11731 		{ "CD", 0x3 },
11732 	},
11733 };
11734 
11735 static struct hda_input_mux alc268_acer_capture_source = {
11736 	.num_items = 3,
11737 	.items = {
11738 		{ "Mic", 0x0 },
11739 		{ "Internal Mic", 0x1 },
11740 		{ "Line", 0x2 },
11741 	},
11742 };
11743 
11744 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11745 	.num_items = 3,
11746 	.items = {
11747 		{ "Mic", 0x0 },
11748 		{ "Internal Mic", 0x6 },
11749 		{ "Line", 0x2 },
11750 	},
11751 };
11752 
11753 #ifdef CONFIG_SND_DEBUG
11754 static struct snd_kcontrol_new alc268_test_mixer[] = {
11755 	/* Volume widgets */
11756 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11757 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11758 	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11759 	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11760 	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11761 	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11762 	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11763 	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11764 	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11765 	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11766 	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11767 	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11768 	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11769 	/* The below appears problematic on some hardwares */
11770 	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11771 	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11772 	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11773 	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11774 	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11775 
11776 	/* Modes for retasking pin widgets */
11777 	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11778 	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11779 	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11780 	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11781 
11782 	/* Controls for GPIO pins, assuming they are configured as outputs */
11783 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11784 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11785 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11786 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11787 
11788 	/* Switches to allow the digital SPDIF output pin to be enabled.
11789 	 * The ALC268 does not have an SPDIF input.
11790 	 */
11791 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11792 
11793 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
11794 	 * this output to turn on an external amplifier.
11795 	 */
11796 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11797 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11798 
11799 	{ } /* end */
11800 };
11801 #endif
11802 
11803 /* create input playback/capture controls for the given pin */
11804 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11805 				    const char *ctlname, int idx)
11806 {
11807 	char name[32];
11808 	int err;
11809 
11810 	sprintf(name, "%s Playback Volume", ctlname);
11811 	if (nid == 0x14) {
11812 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11813 				  HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11814 						      HDA_OUTPUT));
11815 		if (err < 0)
11816 			return err;
11817 	} else if (nid == 0x15) {
11818 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11819 				  HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11820 						      HDA_OUTPUT));
11821 		if (err < 0)
11822 			return err;
11823 	} else
11824 		return -1;
11825 	sprintf(name, "%s Playback Switch", ctlname);
11826 	err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11827 			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11828 	if (err < 0)
11829 		return err;
11830 	return 0;
11831 }
11832 
11833 /* add playback controls from the parsed DAC table */
11834 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11835 					     const struct auto_pin_cfg *cfg)
11836 {
11837 	hda_nid_t nid;
11838 	int err;
11839 
11840 	spec->multiout.num_dacs = 2;	/* only use one dac */
11841 	spec->multiout.dac_nids = spec->private_dac_nids;
11842 	spec->multiout.dac_nids[0] = 2;
11843 	spec->multiout.dac_nids[1] = 3;
11844 
11845 	nid = cfg->line_out_pins[0];
11846 	if (nid)
11847 		alc268_new_analog_output(spec, nid, "Front", 0);
11848 
11849 	nid = cfg->speaker_pins[0];
11850 	if (nid == 0x1d) {
11851 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
11852 				  "Speaker Playback Volume",
11853 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11854 		if (err < 0)
11855 			return err;
11856 	}
11857 	nid = cfg->hp_pins[0];
11858 	if (nid)
11859 		alc268_new_analog_output(spec, nid, "Headphone", 0);
11860 
11861 	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11862 	if (nid == 0x16) {
11863 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11864 				  "Mono Playback Switch",
11865 				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11866 		if (err < 0)
11867 			return err;
11868 	}
11869 	return 0;
11870 }
11871 
11872 /* create playback/capture controls for input pins */
11873 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11874 						const struct auto_pin_cfg *cfg)
11875 {
11876 	struct hda_input_mux *imux = &spec->private_imux[0];
11877 	int i, idx1;
11878 
11879 	for (i = 0; i < AUTO_PIN_LAST; i++) {
11880 		switch(cfg->input_pins[i]) {
11881 		case 0x18:
11882 			idx1 = 0;	/* Mic 1 */
11883 			break;
11884 		case 0x19:
11885 			idx1 = 1;	/* Mic 2 */
11886 			break;
11887 		case 0x1a:
11888 			idx1 = 2;	/* Line In */
11889 			break;
11890 		case 0x1c:
11891 			idx1 = 3;	/* CD */
11892 			break;
11893 		case 0x12:
11894 		case 0x13:
11895 			idx1 = 6;	/* digital mics */
11896 			break;
11897 		default:
11898 			continue;
11899 		}
11900 		imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11901 		imux->items[imux->num_items].index = idx1;
11902 		imux->num_items++;
11903 	}
11904 	return 0;
11905 }
11906 
11907 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11908 {
11909 	struct alc_spec *spec = codec->spec;
11910 	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11911 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11912 	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11913 	unsigned int	dac_vol1, dac_vol2;
11914 
11915 	if (speaker_nid) {
11916 		snd_hda_codec_write(codec, speaker_nid, 0,
11917 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11918 		snd_hda_codec_write(codec, 0x0f, 0,
11919 				    AC_VERB_SET_AMP_GAIN_MUTE,
11920 				    AMP_IN_UNMUTE(1));
11921 		snd_hda_codec_write(codec, 0x10, 0,
11922 				    AC_VERB_SET_AMP_GAIN_MUTE,
11923 				    AMP_IN_UNMUTE(1));
11924 	} else {
11925 		snd_hda_codec_write(codec, 0x0f, 0,
11926 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11927 		snd_hda_codec_write(codec, 0x10, 0,
11928 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11929 	}
11930 
11931 	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
11932 	if (line_nid == 0x14)
11933 		dac_vol2 = AMP_OUT_ZERO;
11934 	else if (line_nid == 0x15)
11935 		dac_vol1 = AMP_OUT_ZERO;
11936 	if (hp_nid == 0x14)
11937 		dac_vol2 = AMP_OUT_ZERO;
11938 	else if (hp_nid == 0x15)
11939 		dac_vol1 = AMP_OUT_ZERO;
11940 	if (line_nid != 0x16 || hp_nid != 0x16 ||
11941 	    spec->autocfg.line_out_pins[1] != 0x16 ||
11942 	    spec->autocfg.line_out_pins[2] != 0x16)
11943 		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11944 
11945 	snd_hda_codec_write(codec, 0x02, 0,
11946 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11947 	snd_hda_codec_write(codec, 0x03, 0,
11948 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11949 }
11950 
11951 /* pcm configuration: identiacal with ALC880 */
11952 #define alc268_pcm_analog_playback	alc880_pcm_analog_playback
11953 #define alc268_pcm_analog_capture	alc880_pcm_analog_capture
11954 #define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
11955 #define alc268_pcm_digital_playback	alc880_pcm_digital_playback
11956 
11957 /*
11958  * BIOS auto configuration
11959  */
11960 static int alc268_parse_auto_config(struct hda_codec *codec)
11961 {
11962 	struct alc_spec *spec = codec->spec;
11963 	int err;
11964 	static hda_nid_t alc268_ignore[] = { 0 };
11965 
11966 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11967 					   alc268_ignore);
11968 	if (err < 0)
11969 		return err;
11970 	if (!spec->autocfg.line_outs) {
11971 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11972 			spec->multiout.max_channels = 2;
11973 			spec->no_analog = 1;
11974 			goto dig_only;
11975 		}
11976 		return 0; /* can't find valid BIOS pin config */
11977 	}
11978 	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11979 	if (err < 0)
11980 		return err;
11981 	err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11982 	if (err < 0)
11983 		return err;
11984 
11985 	spec->multiout.max_channels = 2;
11986 
11987  dig_only:
11988 	/* digital only support output */
11989 	if (spec->autocfg.dig_outs) {
11990 		spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11991 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
11992 	}
11993 	if (spec->kctls.list)
11994 		add_mixer(spec, spec->kctls.list);
11995 
11996 	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
11997 		add_mixer(spec, alc268_beep_mixer);
11998 
11999 	add_verb(spec, alc268_volume_init_verbs);
12000 	spec->num_mux_defs = 1;
12001 	spec->input_mux = &spec->private_imux[0];
12002 
12003 	err = alc_auto_add_mic_boost(codec);
12004 	if (err < 0)
12005 		return err;
12006 
12007 	return 1;
12008 }
12009 
12010 #define alc268_auto_init_multi_out	alc882_auto_init_multi_out
12011 #define alc268_auto_init_hp_out		alc882_auto_init_hp_out
12012 #define alc268_auto_init_analog_input	alc882_auto_init_analog_input
12013 
12014 /* init callback for auto-configuration model -- overriding the default init */
12015 static void alc268_auto_init(struct hda_codec *codec)
12016 {
12017 	struct alc_spec *spec = codec->spec;
12018 	alc268_auto_init_multi_out(codec);
12019 	alc268_auto_init_hp_out(codec);
12020 	alc268_auto_init_mono_speaker_out(codec);
12021 	alc268_auto_init_analog_input(codec);
12022 	if (spec->unsol_event)
12023 		alc_inithook(codec);
12024 }
12025 
12026 /*
12027  * configuration and preset
12028  */
12029 static const char *alc268_models[ALC268_MODEL_LAST] = {
12030 	[ALC267_QUANTA_IL1]	= "quanta-il1",
12031 	[ALC268_3ST]		= "3stack",
12032 	[ALC268_TOSHIBA]	= "toshiba",
12033 	[ALC268_ACER]		= "acer",
12034 	[ALC268_ACER_DMIC]	= "acer-dmic",
12035 	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
12036 	[ALC268_DELL]		= "dell",
12037 	[ALC268_ZEPTO]		= "zepto",
12038 #ifdef CONFIG_SND_DEBUG
12039 	[ALC268_TEST]		= "test",
12040 #endif
12041 	[ALC268_AUTO]		= "auto",
12042 };
12043 
12044 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12045 	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12046 	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12047 	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12048 	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12049 	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12050 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12051 						ALC268_ACER_ASPIRE_ONE),
12052 	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12053 	SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12054 	SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
12055 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12056 	SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
12057 	SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
12058 	SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
12059 	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12060 	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12061 	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12062 	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12063 	{}
12064 };
12065 
12066 static struct alc_config_preset alc268_presets[] = {
12067 	[ALC267_QUANTA_IL1] = {
12068 		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12069 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12070 				alc267_quanta_il1_verbs },
12071 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12072 		.dac_nids = alc268_dac_nids,
12073 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12074 		.adc_nids = alc268_adc_nids_alt,
12075 		.hp_nid = 0x03,
12076 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12077 		.channel_mode = alc268_modes,
12078 		.input_mux = &alc268_capture_source,
12079 		.unsol_event = alc267_quanta_il1_unsol_event,
12080 		.init_hook = alc267_quanta_il1_automute,
12081 	},
12082 	[ALC268_3ST] = {
12083 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12084 			    alc268_beep_mixer },
12085 		.init_verbs = { alc268_base_init_verbs },
12086 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12087 		.dac_nids = alc268_dac_nids,
12088                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12089                 .adc_nids = alc268_adc_nids_alt,
12090 		.capsrc_nids = alc268_capsrc_nids,
12091 		.hp_nid = 0x03,
12092 		.dig_out_nid = ALC268_DIGOUT_NID,
12093 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12094 		.channel_mode = alc268_modes,
12095 		.input_mux = &alc268_capture_source,
12096 	},
12097 	[ALC268_TOSHIBA] = {
12098 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12099 			    alc268_beep_mixer },
12100 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12101 				alc268_toshiba_verbs },
12102 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12103 		.dac_nids = alc268_dac_nids,
12104 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12105 		.adc_nids = alc268_adc_nids_alt,
12106 		.capsrc_nids = alc268_capsrc_nids,
12107 		.hp_nid = 0x03,
12108 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12109 		.channel_mode = alc268_modes,
12110 		.input_mux = &alc268_capture_source,
12111 		.unsol_event = alc268_toshiba_unsol_event,
12112 		.init_hook = alc268_toshiba_automute,
12113 	},
12114 	[ALC268_ACER] = {
12115 		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12116 			    alc268_beep_mixer },
12117 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12118 				alc268_acer_verbs },
12119 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12120 		.dac_nids = alc268_dac_nids,
12121 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12122 		.adc_nids = alc268_adc_nids_alt,
12123 		.capsrc_nids = alc268_capsrc_nids,
12124 		.hp_nid = 0x02,
12125 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12126 		.channel_mode = alc268_modes,
12127 		.input_mux = &alc268_acer_capture_source,
12128 		.unsol_event = alc268_acer_unsol_event,
12129 		.init_hook = alc268_acer_init_hook,
12130 	},
12131 	[ALC268_ACER_DMIC] = {
12132 		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12133 			    alc268_beep_mixer },
12134 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12135 				alc268_acer_verbs },
12136 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12137 		.dac_nids = alc268_dac_nids,
12138 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12139 		.adc_nids = alc268_adc_nids_alt,
12140 		.capsrc_nids = alc268_capsrc_nids,
12141 		.hp_nid = 0x02,
12142 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12143 		.channel_mode = alc268_modes,
12144 		.input_mux = &alc268_acer_dmic_capture_source,
12145 		.unsol_event = alc268_acer_unsol_event,
12146 		.init_hook = alc268_acer_init_hook,
12147 	},
12148 	[ALC268_ACER_ASPIRE_ONE] = {
12149 		.mixers = { alc268_acer_aspire_one_mixer,
12150 			    alc268_beep_mixer,
12151 			    alc268_capture_alt_mixer },
12152 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12153 				alc268_acer_aspire_one_verbs },
12154 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12155 		.dac_nids = alc268_dac_nids,
12156 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12157 		.adc_nids = alc268_adc_nids_alt,
12158 		.capsrc_nids = alc268_capsrc_nids,
12159 		.hp_nid = 0x03,
12160 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12161 		.channel_mode = alc268_modes,
12162 		.input_mux = &alc268_acer_lc_capture_source,
12163 		.unsol_event = alc268_acer_lc_unsol_event,
12164 		.init_hook = alc268_acer_lc_init_hook,
12165 	},
12166 	[ALC268_DELL] = {
12167 		.mixers = { alc268_dell_mixer, alc268_beep_mixer },
12168 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12169 				alc268_dell_verbs },
12170 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12171 		.dac_nids = alc268_dac_nids,
12172 		.hp_nid = 0x02,
12173 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12174 		.channel_mode = alc268_modes,
12175 		.unsol_event = alc268_dell_unsol_event,
12176 		.init_hook = alc268_dell_init_hook,
12177 		.input_mux = &alc268_capture_source,
12178 	},
12179 	[ALC268_ZEPTO] = {
12180 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12181 			    alc268_beep_mixer },
12182 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12183 				alc268_toshiba_verbs },
12184 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12185 		.dac_nids = alc268_dac_nids,
12186 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12187 		.adc_nids = alc268_adc_nids_alt,
12188 		.capsrc_nids = alc268_capsrc_nids,
12189 		.hp_nid = 0x03,
12190 		.dig_out_nid = ALC268_DIGOUT_NID,
12191 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12192 		.channel_mode = alc268_modes,
12193 		.input_mux = &alc268_capture_source,
12194 		.unsol_event = alc268_toshiba_unsol_event,
12195 		.init_hook = alc268_toshiba_automute
12196 	},
12197 #ifdef CONFIG_SND_DEBUG
12198 	[ALC268_TEST] = {
12199 		.mixers = { alc268_test_mixer, alc268_capture_mixer },
12200 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12201 				alc268_volume_init_verbs },
12202 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12203 		.dac_nids = alc268_dac_nids,
12204 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12205 		.adc_nids = alc268_adc_nids_alt,
12206 		.capsrc_nids = alc268_capsrc_nids,
12207 		.hp_nid = 0x03,
12208 		.dig_out_nid = ALC268_DIGOUT_NID,
12209 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12210 		.channel_mode = alc268_modes,
12211 		.input_mux = &alc268_capture_source,
12212 	},
12213 #endif
12214 };
12215 
12216 static int patch_alc268(struct hda_codec *codec)
12217 {
12218 	struct alc_spec *spec;
12219 	int board_config;
12220 	int i, has_beep, err;
12221 
12222 	spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12223 	if (spec == NULL)
12224 		return -ENOMEM;
12225 
12226 	codec->spec = spec;
12227 
12228 	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12229 						  alc268_models,
12230 						  alc268_cfg_tbl);
12231 
12232 	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12233 		printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12234 		       "trying auto-probe from BIOS...\n");
12235 		board_config = ALC268_AUTO;
12236 	}
12237 
12238 	if (board_config == ALC268_AUTO) {
12239 		/* automatic parse from the BIOS config */
12240 		err = alc268_parse_auto_config(codec);
12241 		if (err < 0) {
12242 			alc_free(codec);
12243 			return err;
12244 		} else if (!err) {
12245 			printk(KERN_INFO
12246 			       "hda_codec: Cannot set up configuration "
12247 			       "from BIOS.  Using base mode...\n");
12248 			board_config = ALC268_3ST;
12249 		}
12250 	}
12251 
12252 	if (board_config != ALC268_AUTO)
12253 		setup_preset(spec, &alc268_presets[board_config]);
12254 
12255 	if (codec->vendor_id == 0x10ec0267) {
12256 		spec->stream_name_analog = "ALC267 Analog";
12257 		spec->stream_name_digital = "ALC267 Digital";
12258 	} else {
12259 		spec->stream_name_analog = "ALC268 Analog";
12260 		spec->stream_name_digital = "ALC268 Digital";
12261 	}
12262 
12263 	spec->stream_analog_playback = &alc268_pcm_analog_playback;
12264 	spec->stream_analog_capture = &alc268_pcm_analog_capture;
12265 	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12266 
12267 	spec->stream_digital_playback = &alc268_pcm_digital_playback;
12268 
12269 	has_beep = 0;
12270 	for (i = 0; i < spec->num_mixers; i++) {
12271 		if (spec->mixers[i] == alc268_beep_mixer) {
12272 			has_beep = 1;
12273 			break;
12274 		}
12275 	}
12276 
12277 	if (has_beep) {
12278 		err = snd_hda_attach_beep_device(codec, 0x1);
12279 		if (err < 0) {
12280 			alc_free(codec);
12281 			return err;
12282 		}
12283 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12284 			/* override the amp caps for beep generator */
12285 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12286 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12287 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12288 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12289 					  (0 << AC_AMPCAP_MUTE_SHIFT));
12290 	}
12291 
12292 	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12293 		/* check whether NID 0x07 is valid */
12294 		unsigned int wcap = get_wcaps(codec, 0x07);
12295 		int i;
12296 
12297 		/* get type */
12298 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12299 		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12300 			spec->adc_nids = alc268_adc_nids_alt;
12301 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12302 			add_mixer(spec, alc268_capture_alt_mixer);
12303 		} else {
12304 			spec->adc_nids = alc268_adc_nids;
12305 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12306 			add_mixer(spec, alc268_capture_mixer);
12307 		}
12308 		spec->capsrc_nids = alc268_capsrc_nids;
12309 		/* set default input source */
12310 		for (i = 0; i < spec->num_adc_nids; i++)
12311 			snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12312 				0, AC_VERB_SET_CONNECT_SEL,
12313 				spec->input_mux->items[0].index);
12314 	}
12315 
12316 	spec->vmaster_nid = 0x02;
12317 
12318 	codec->patch_ops = alc_patch_ops;
12319 	if (board_config == ALC268_AUTO)
12320 		spec->init_hook = alc268_auto_init;
12321 
12322 	codec->proc_widget_hook = print_realtek_coef;
12323 
12324 	return 0;
12325 }
12326 
12327 /*
12328  *  ALC269 channel source setting (2 channel)
12329  */
12330 #define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
12331 
12332 #define alc269_dac_nids		alc260_dac_nids
12333 
12334 static hda_nid_t alc269_adc_nids[1] = {
12335 	/* ADC1 */
12336 	0x08,
12337 };
12338 
12339 static hda_nid_t alc269_capsrc_nids[1] = {
12340 	0x23,
12341 };
12342 
12343 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12344  *       not a mux!
12345  */
12346 
12347 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12348 	.num_items = 2,
12349 	.items = {
12350 		{ "i-Mic", 0x5 },
12351 		{ "e-Mic", 0x0 },
12352 	},
12353 };
12354 
12355 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12356 	.num_items = 2,
12357 	.items = {
12358 		{ "i-Mic", 0x1 },
12359 		{ "e-Mic", 0x0 },
12360 	},
12361 };
12362 
12363 #define alc269_modes		alc260_modes
12364 #define alc269_capture_source	alc880_lg_lw_capture_source
12365 
12366 static struct snd_kcontrol_new alc269_base_mixer[] = {
12367 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12368 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12369 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12370 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12371 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12372 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12373 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12374 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12375 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12376 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12377 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12378 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12379 	{ } /* end */
12380 };
12381 
12382 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12383 	/* output mixer control */
12384 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12385 	{
12386 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12387 		.name = "Master Playback Switch",
12388 		.info = snd_hda_mixer_amp_switch_info,
12389 		.get = snd_hda_mixer_amp_switch_get,
12390 		.put = alc268_acer_master_sw_put,
12391 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12392 	},
12393 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12394 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12395 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12396 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12397 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12398 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12399 	{ }
12400 };
12401 
12402 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12403 	/* output mixer control */
12404 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12405 	{
12406 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12407 		.name = "Master Playback Switch",
12408 		.info = snd_hda_mixer_amp_switch_info,
12409 		.get = snd_hda_mixer_amp_switch_get,
12410 		.put = alc268_acer_master_sw_put,
12411 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12412 	},
12413 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12414 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12415 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12416 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12417 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12418 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12419 	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12420 	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12421 	HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12422 	{ }
12423 };
12424 
12425 /* bind volumes of both NID 0x0c and 0x0d */
12426 static struct hda_bind_ctls alc269_epc_bind_vol = {
12427 	.ops = &snd_hda_bind_vol,
12428 	.values = {
12429 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12430 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12431 		0
12432 	},
12433 };
12434 
12435 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12436 	HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12437 	HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12438 	HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12439 	{ } /* end */
12440 };
12441 
12442 /* capture mixer elements */
12443 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12444 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12445 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12446 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12447 	{ } /* end */
12448 };
12449 
12450 /* FSC amilo */
12451 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12452 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12453 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12454 	HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12455 	{ } /* end */
12456 };
12457 
12458 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12459 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12460 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12461 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12462 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12463 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12464 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12465 	{ }
12466 };
12467 
12468 static struct hda_verb alc269_lifebook_verbs[] = {
12469 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12470 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12471 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12472 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12473 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12474 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12475 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12476 	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12477 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12478 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12479 	{ }
12480 };
12481 
12482 /* toggle speaker-output according to the hp-jack state */
12483 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12484 {
12485 	unsigned int present;
12486 	unsigned char bits;
12487 
12488 	present = snd_hda_codec_read(codec, 0x15, 0,
12489 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12490 	bits = present ? AMP_IN_MUTE(0) : 0;
12491 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12492 			AMP_IN_MUTE(0), bits);
12493 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12494 			AMP_IN_MUTE(0), bits);
12495 
12496 	snd_hda_codec_write(codec, 0x20, 0,
12497 			AC_VERB_SET_COEF_INDEX, 0x0c);
12498 	snd_hda_codec_write(codec, 0x20, 0,
12499 			AC_VERB_SET_PROC_COEF, 0x680);
12500 
12501 	snd_hda_codec_write(codec, 0x20, 0,
12502 			AC_VERB_SET_COEF_INDEX, 0x0c);
12503 	snd_hda_codec_write(codec, 0x20, 0,
12504 			AC_VERB_SET_PROC_COEF, 0x480);
12505 }
12506 
12507 /* toggle speaker-output according to the hp-jacks state */
12508 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12509 {
12510 	unsigned int present;
12511 	unsigned char bits;
12512 
12513 	/* Check laptop headphone socket */
12514 	present = snd_hda_codec_read(codec, 0x15, 0,
12515 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12516 
12517 	/* Check port replicator headphone socket */
12518 	present |= snd_hda_codec_read(codec, 0x1a, 0,
12519 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12520 
12521 	bits = present ? AMP_IN_MUTE(0) : 0;
12522 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12523 			AMP_IN_MUTE(0), bits);
12524 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12525 			AMP_IN_MUTE(0), bits);
12526 
12527 	snd_hda_codec_write(codec, 0x20, 0,
12528 			AC_VERB_SET_COEF_INDEX, 0x0c);
12529 	snd_hda_codec_write(codec, 0x20, 0,
12530 			AC_VERB_SET_PROC_COEF, 0x680);
12531 
12532 	snd_hda_codec_write(codec, 0x20, 0,
12533 			AC_VERB_SET_COEF_INDEX, 0x0c);
12534 	snd_hda_codec_write(codec, 0x20, 0,
12535 			AC_VERB_SET_PROC_COEF, 0x480);
12536 }
12537 
12538 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12539 {
12540 	unsigned int present;
12541 
12542 	present = snd_hda_codec_read(codec, 0x18, 0,
12543 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12544 	snd_hda_codec_write(codec, 0x23, 0,
12545 			    AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12546 }
12547 
12548 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12549 {
12550 	unsigned int present_laptop;
12551 	unsigned int present_dock;
12552 
12553 	present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12554 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12555 
12556 	present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12557 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12558 
12559 	/* Laptop mic port overrides dock mic port, design decision */
12560 	if (present_dock)
12561 		snd_hda_codec_write(codec, 0x23, 0,
12562 				AC_VERB_SET_CONNECT_SEL, 0x3);
12563 	if (present_laptop)
12564 		snd_hda_codec_write(codec, 0x23, 0,
12565 				AC_VERB_SET_CONNECT_SEL, 0x0);
12566 	if (!present_dock && !present_laptop)
12567 		snd_hda_codec_write(codec, 0x23, 0,
12568 				AC_VERB_SET_CONNECT_SEL, 0x1);
12569 }
12570 
12571 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12572 				    unsigned int res)
12573 {
12574 	if ((res >> 26) == ALC880_HP_EVENT)
12575 		alc269_quanta_fl1_speaker_automute(codec);
12576 	if ((res >> 26) == ALC880_MIC_EVENT)
12577 		alc269_quanta_fl1_mic_automute(codec);
12578 }
12579 
12580 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12581 					unsigned int res)
12582 {
12583 	if ((res >> 26) == ALC880_HP_EVENT)
12584 		alc269_lifebook_speaker_automute(codec);
12585 	if ((res >> 26) == ALC880_MIC_EVENT)
12586 		alc269_lifebook_mic_autoswitch(codec);
12587 }
12588 
12589 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12590 {
12591 	alc269_quanta_fl1_speaker_automute(codec);
12592 	alc269_quanta_fl1_mic_automute(codec);
12593 }
12594 
12595 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12596 {
12597 	alc269_lifebook_speaker_automute(codec);
12598 	alc269_lifebook_mic_autoswitch(codec);
12599 }
12600 
12601 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12602 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12603 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12604 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12605 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12606 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12607 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12608 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12609 	{}
12610 };
12611 
12612 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12613 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12614 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12615 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12616 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12617 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12618 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12619 	{}
12620 };
12621 
12622 /* toggle speaker-output according to the hp-jack state */
12623 static void alc269_speaker_automute(struct hda_codec *codec)
12624 {
12625 	unsigned int present;
12626 	unsigned char bits;
12627 
12628 	present = snd_hda_codec_read(codec, 0x15, 0,
12629 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12630 	bits = present ? AMP_IN_MUTE(0) : 0;
12631 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12632 				AMP_IN_MUTE(0), bits);
12633 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12634 				AMP_IN_MUTE(0), bits);
12635 }
12636 
12637 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12638 {
12639 	unsigned int present;
12640 
12641 	present = snd_hda_codec_read(codec, 0x18, 0,
12642 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12643 	snd_hda_codec_write(codec, 0x23, 0,
12644 				AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12645 }
12646 
12647 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12648 {
12649 	unsigned int present;
12650 
12651 	present = snd_hda_codec_read(codec, 0x18, 0,
12652 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12653 	snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12654 				0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12655 	snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12656 				0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12657 }
12658 
12659 /* unsolicited event for HP jack sensing */
12660 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12661 				     unsigned int res)
12662 {
12663 	if ((res >> 26) == ALC880_HP_EVENT)
12664 		alc269_speaker_automute(codec);
12665 
12666 	if ((res >> 26) == ALC880_MIC_EVENT)
12667 		alc269_eeepc_dmic_automute(codec);
12668 }
12669 
12670 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12671 {
12672 	alc269_speaker_automute(codec);
12673 	alc269_eeepc_dmic_automute(codec);
12674 }
12675 
12676 /* unsolicited event for HP jack sensing */
12677 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12678 				     unsigned int res)
12679 {
12680 	if ((res >> 26) == ALC880_HP_EVENT)
12681 		alc269_speaker_automute(codec);
12682 
12683 	if ((res >> 26) == ALC880_MIC_EVENT)
12684 		alc269_eeepc_amic_automute(codec);
12685 }
12686 
12687 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12688 {
12689 	alc269_speaker_automute(codec);
12690 	alc269_eeepc_amic_automute(codec);
12691 }
12692 
12693 /*
12694  * generic initialization of ADC, input mixers and output mixers
12695  */
12696 static struct hda_verb alc269_init_verbs[] = {
12697 	/*
12698 	 * Unmute ADC0 and set the default input to mic-in
12699 	 */
12700 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12701 
12702 	/* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12703 	 * analog-loopback mixer widget
12704 	 * Note: PASD motherboards uses the Line In 2 as the input for
12705 	 * front panel mic (mic 2)
12706 	 */
12707 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12708 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12709 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12710 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12711 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12712 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12713 
12714 	/*
12715 	 * Set up output mixers (0x0c - 0x0e)
12716 	 */
12717 	/* set vol=0 to output mixers */
12718 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12719 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12720 
12721 	/* set up input amps for analog loopback */
12722 	/* Amp Indices: DAC = 0, mixer = 1 */
12723 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12724 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12725 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12726 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12727 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12728 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12729 
12730 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12731 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12732 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12733 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12734 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12735 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12736 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12737 
12738 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12739 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12740 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12741 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12742 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12743 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12744 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12745 
12746 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12747 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12748 
12749 	/* FIXME: use matrix-type input source selection */
12750 	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12751 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12752 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12753 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12754 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12755 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12756 
12757 	/* set EAPD */
12758 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12759 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12760 	{ }
12761 };
12762 
12763 /* add playback controls from the parsed DAC table */
12764 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12765 					     const struct auto_pin_cfg *cfg)
12766 {
12767 	hda_nid_t nid;
12768 	int err;
12769 
12770 	spec->multiout.num_dacs = 1;	/* only use one dac */
12771 	spec->multiout.dac_nids = spec->private_dac_nids;
12772 	spec->multiout.dac_nids[0] = 2;
12773 
12774 	nid = cfg->line_out_pins[0];
12775 	if (nid) {
12776 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
12777 				  "Front Playback Volume",
12778 				  HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12779 		if (err < 0)
12780 			return err;
12781 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12782 				  "Front Playback Switch",
12783 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12784 		if (err < 0)
12785 			return err;
12786 	}
12787 
12788 	nid = cfg->speaker_pins[0];
12789 	if (nid) {
12790 		if (!cfg->line_out_pins[0]) {
12791 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
12792 					  "Speaker Playback Volume",
12793 					  HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12794 							      HDA_OUTPUT));
12795 			if (err < 0)
12796 				return err;
12797 		}
12798 		if (nid == 0x16) {
12799 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12800 					  "Speaker Playback Switch",
12801 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12802 							      HDA_OUTPUT));
12803 			if (err < 0)
12804 				return err;
12805 		} else {
12806 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12807 					  "Speaker Playback Switch",
12808 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12809 							      HDA_OUTPUT));
12810 			if (err < 0)
12811 				return err;
12812 		}
12813 	}
12814 	nid = cfg->hp_pins[0];
12815 	if (nid) {
12816 		/* spec->multiout.hp_nid = 2; */
12817 		if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12818 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
12819 					  "Headphone Playback Volume",
12820 					  HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12821 							      HDA_OUTPUT));
12822 			if (err < 0)
12823 				return err;
12824 		}
12825 		if (nid == 0x16) {
12826 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12827 					  "Headphone Playback Switch",
12828 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12829 							      HDA_OUTPUT));
12830 			if (err < 0)
12831 				return err;
12832 		} else {
12833 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12834 					  "Headphone Playback Switch",
12835 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12836 							      HDA_OUTPUT));
12837 			if (err < 0)
12838 				return err;
12839 		}
12840 	}
12841 	return 0;
12842 }
12843 
12844 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12845 						const struct auto_pin_cfg *cfg)
12846 {
12847 	int err;
12848 
12849 	err = alc880_auto_create_analog_input_ctls(spec, cfg);
12850 	if (err < 0)
12851 		return err;
12852 	/* digital-mic input pin is excluded in alc880_auto_create..()
12853 	 * because it's under 0x18
12854 	 */
12855 	if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12856 	    cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12857 		struct hda_input_mux *imux = &spec->private_imux[0];
12858 		imux->items[imux->num_items].label = "Int Mic";
12859 		imux->items[imux->num_items].index = 0x05;
12860 		imux->num_items++;
12861 	}
12862 	return 0;
12863 }
12864 
12865 #ifdef CONFIG_SND_HDA_POWER_SAVE
12866 #define alc269_loopbacks	alc880_loopbacks
12867 #endif
12868 
12869 /* pcm configuration: identiacal with ALC880 */
12870 #define alc269_pcm_analog_playback	alc880_pcm_analog_playback
12871 #define alc269_pcm_analog_capture	alc880_pcm_analog_capture
12872 #define alc269_pcm_digital_playback	alc880_pcm_digital_playback
12873 #define alc269_pcm_digital_capture	alc880_pcm_digital_capture
12874 
12875 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12876 	.substreams = 1,
12877 	.channels_min = 2,
12878 	.channels_max = 8,
12879 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12880 	/* NID is set in alc_build_pcms */
12881 	.ops = {
12882 		.open = alc880_playback_pcm_open,
12883 		.prepare = alc880_playback_pcm_prepare,
12884 		.cleanup = alc880_playback_pcm_cleanup
12885 	},
12886 };
12887 
12888 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12889 	.substreams = 1,
12890 	.channels_min = 2,
12891 	.channels_max = 2,
12892 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12893 	/* NID is set in alc_build_pcms */
12894 };
12895 
12896 /*
12897  * BIOS auto configuration
12898  */
12899 static int alc269_parse_auto_config(struct hda_codec *codec)
12900 {
12901 	struct alc_spec *spec = codec->spec;
12902 	int err;
12903 	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12904 
12905 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12906 					   alc269_ignore);
12907 	if (err < 0)
12908 		return err;
12909 
12910 	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12911 	if (err < 0)
12912 		return err;
12913 	err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12914 	if (err < 0)
12915 		return err;
12916 
12917 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12918 
12919 	if (spec->autocfg.dig_outs)
12920 		spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12921 
12922 	if (spec->kctls.list)
12923 		add_mixer(spec, spec->kctls.list);
12924 
12925 	add_verb(spec, alc269_init_verbs);
12926 	spec->num_mux_defs = 1;
12927 	spec->input_mux = &spec->private_imux[0];
12928 	/* set default input source */
12929 	snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12930 				  0, AC_VERB_SET_CONNECT_SEL,
12931 				  spec->input_mux->items[0].index);
12932 
12933 	err = alc_auto_add_mic_boost(codec);
12934 	if (err < 0)
12935 		return err;
12936 
12937 	if (!spec->cap_mixer && !spec->no_analog)
12938 		set_capture_mixer(spec);
12939 
12940 	return 1;
12941 }
12942 
12943 #define alc269_auto_init_multi_out	alc882_auto_init_multi_out
12944 #define alc269_auto_init_hp_out		alc882_auto_init_hp_out
12945 #define alc269_auto_init_analog_input	alc882_auto_init_analog_input
12946 
12947 
12948 /* init callback for auto-configuration model -- overriding the default init */
12949 static void alc269_auto_init(struct hda_codec *codec)
12950 {
12951 	struct alc_spec *spec = codec->spec;
12952 	alc269_auto_init_multi_out(codec);
12953 	alc269_auto_init_hp_out(codec);
12954 	alc269_auto_init_analog_input(codec);
12955 	if (spec->unsol_event)
12956 		alc_inithook(codec);
12957 }
12958 
12959 /*
12960  * configuration and preset
12961  */
12962 static const char *alc269_models[ALC269_MODEL_LAST] = {
12963 	[ALC269_BASIC]			= "basic",
12964 	[ALC269_QUANTA_FL1]		= "quanta",
12965 	[ALC269_ASUS_EEEPC_P703]	= "eeepc-p703",
12966 	[ALC269_ASUS_EEEPC_P901]	= "eeepc-p901",
12967 	[ALC269_FUJITSU]		= "fujitsu",
12968 	[ALC269_LIFEBOOK]		= "lifebook"
12969 };
12970 
12971 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12972 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12973 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12974 		      ALC269_ASUS_EEEPC_P703),
12975 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12976 		      ALC269_ASUS_EEEPC_P901),
12977 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12978 		      ALC269_ASUS_EEEPC_P901),
12979 	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12980 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12981 	{}
12982 };
12983 
12984 static struct alc_config_preset alc269_presets[] = {
12985 	[ALC269_BASIC] = {
12986 		.mixers = { alc269_base_mixer },
12987 		.init_verbs = { alc269_init_verbs },
12988 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
12989 		.dac_nids = alc269_dac_nids,
12990 		.hp_nid = 0x03,
12991 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
12992 		.channel_mode = alc269_modes,
12993 		.input_mux = &alc269_capture_source,
12994 	},
12995 	[ALC269_QUANTA_FL1] = {
12996 		.mixers = { alc269_quanta_fl1_mixer },
12997 		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
12998 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
12999 		.dac_nids = alc269_dac_nids,
13000 		.hp_nid = 0x03,
13001 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13002 		.channel_mode = alc269_modes,
13003 		.input_mux = &alc269_capture_source,
13004 		.unsol_event = alc269_quanta_fl1_unsol_event,
13005 		.init_hook = alc269_quanta_fl1_init_hook,
13006 	},
13007 	[ALC269_ASUS_EEEPC_P703] = {
13008 		.mixers = { alc269_eeepc_mixer },
13009 		.cap_mixer = alc269_epc_capture_mixer,
13010 		.init_verbs = { alc269_init_verbs,
13011 				alc269_eeepc_amic_init_verbs },
13012 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13013 		.dac_nids = alc269_dac_nids,
13014 		.hp_nid = 0x03,
13015 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13016 		.channel_mode = alc269_modes,
13017 		.input_mux = &alc269_eeepc_amic_capture_source,
13018 		.unsol_event = alc269_eeepc_amic_unsol_event,
13019 		.init_hook = alc269_eeepc_amic_inithook,
13020 	},
13021 	[ALC269_ASUS_EEEPC_P901] = {
13022 		.mixers = { alc269_eeepc_mixer },
13023 		.cap_mixer = alc269_epc_capture_mixer,
13024 		.init_verbs = { alc269_init_verbs,
13025 				alc269_eeepc_dmic_init_verbs },
13026 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13027 		.dac_nids = alc269_dac_nids,
13028 		.hp_nid = 0x03,
13029 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13030 		.channel_mode = alc269_modes,
13031 		.input_mux = &alc269_eeepc_dmic_capture_source,
13032 		.unsol_event = alc269_eeepc_dmic_unsol_event,
13033 		.init_hook = alc269_eeepc_dmic_inithook,
13034 	},
13035 	[ALC269_FUJITSU] = {
13036 		.mixers = { alc269_fujitsu_mixer },
13037 		.cap_mixer = alc269_epc_capture_mixer,
13038 		.init_verbs = { alc269_init_verbs,
13039 				alc269_eeepc_dmic_init_verbs },
13040 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13041 		.dac_nids = alc269_dac_nids,
13042 		.hp_nid = 0x03,
13043 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13044 		.channel_mode = alc269_modes,
13045 		.input_mux = &alc269_eeepc_dmic_capture_source,
13046 		.unsol_event = alc269_eeepc_dmic_unsol_event,
13047 		.init_hook = alc269_eeepc_dmic_inithook,
13048 	},
13049 	[ALC269_LIFEBOOK] = {
13050 		.mixers = { alc269_lifebook_mixer },
13051 		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13052 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13053 		.dac_nids = alc269_dac_nids,
13054 		.hp_nid = 0x03,
13055 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13056 		.channel_mode = alc269_modes,
13057 		.input_mux = &alc269_capture_source,
13058 		.unsol_event = alc269_lifebook_unsol_event,
13059 		.init_hook = alc269_lifebook_init_hook,
13060 	},
13061 };
13062 
13063 static int patch_alc269(struct hda_codec *codec)
13064 {
13065 	struct alc_spec *spec;
13066 	int board_config;
13067 	int err;
13068 
13069 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13070 	if (spec == NULL)
13071 		return -ENOMEM;
13072 
13073 	codec->spec = spec;
13074 
13075 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
13076 
13077 	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13078 						  alc269_models,
13079 						  alc269_cfg_tbl);
13080 
13081 	if (board_config < 0) {
13082 		printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
13083 		       "trying auto-probe from BIOS...\n");
13084 		board_config = ALC269_AUTO;
13085 	}
13086 
13087 	if (board_config == ALC269_AUTO) {
13088 		/* automatic parse from the BIOS config */
13089 		err = alc269_parse_auto_config(codec);
13090 		if (err < 0) {
13091 			alc_free(codec);
13092 			return err;
13093 		} else if (!err) {
13094 			printk(KERN_INFO
13095 			       "hda_codec: Cannot set up configuration "
13096 			       "from BIOS.  Using base mode...\n");
13097 			board_config = ALC269_BASIC;
13098 		}
13099 	}
13100 
13101 	err = snd_hda_attach_beep_device(codec, 0x1);
13102 	if (err < 0) {
13103 		alc_free(codec);
13104 		return err;
13105 	}
13106 
13107 	if (board_config != ALC269_AUTO)
13108 		setup_preset(spec, &alc269_presets[board_config]);
13109 
13110 	spec->stream_name_analog = "ALC269 Analog";
13111 	if (codec->subsystem_id == 0x17aa3bf8) {
13112 		/* Due to a hardware problem on Lenovo Ideadpad, we need to
13113 		 * fix the sample rate of analog I/O to 44.1kHz
13114 		 */
13115 		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13116 		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13117 	} else {
13118 		spec->stream_analog_playback = &alc269_pcm_analog_playback;
13119 		spec->stream_analog_capture = &alc269_pcm_analog_capture;
13120 	}
13121 	spec->stream_name_digital = "ALC269 Digital";
13122 	spec->stream_digital_playback = &alc269_pcm_digital_playback;
13123 	spec->stream_digital_capture = &alc269_pcm_digital_capture;
13124 
13125 	spec->adc_nids = alc269_adc_nids;
13126 	spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13127 	spec->capsrc_nids = alc269_capsrc_nids;
13128 	if (!spec->cap_mixer)
13129 		set_capture_mixer(spec);
13130 	set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13131 
13132 	codec->patch_ops = alc_patch_ops;
13133 	if (board_config == ALC269_AUTO)
13134 		spec->init_hook = alc269_auto_init;
13135 #ifdef CONFIG_SND_HDA_POWER_SAVE
13136 	if (!spec->loopback.amplist)
13137 		spec->loopback.amplist = alc269_loopbacks;
13138 #endif
13139 	codec->proc_widget_hook = print_realtek_coef;
13140 
13141 	return 0;
13142 }
13143 
13144 /*
13145  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13146  */
13147 
13148 /*
13149  * set the path ways for 2 channel output
13150  * need to set the codec line out and mic 1 pin widgets to inputs
13151  */
13152 static struct hda_verb alc861_threestack_ch2_init[] = {
13153 	/* set pin widget 1Ah (line in) for input */
13154 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13155 	/* set pin widget 18h (mic1/2) for input, for mic also enable
13156 	 * the vref
13157 	 */
13158 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13159 
13160 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13161 #if 0
13162 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13163 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13164 #endif
13165 	{ } /* end */
13166 };
13167 /*
13168  * 6ch mode
13169  * need to set the codec line out and mic 1 pin widgets to outputs
13170  */
13171 static struct hda_verb alc861_threestack_ch6_init[] = {
13172 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
13173 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13174 	/* set pin widget 18h (mic1) for output (CLFE)*/
13175 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13176 
13177 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13178 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13179 
13180 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13181 #if 0
13182 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13183 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13184 #endif
13185 	{ } /* end */
13186 };
13187 
13188 static struct hda_channel_mode alc861_threestack_modes[2] = {
13189 	{ 2, alc861_threestack_ch2_init },
13190 	{ 6, alc861_threestack_ch6_init },
13191 };
13192 /* Set mic1 as input and unmute the mixer */
13193 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13194 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13195 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13196 	{ } /* end */
13197 };
13198 /* Set mic1 as output and mute mixer */
13199 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13200 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13201 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13202 	{ } /* end */
13203 };
13204 
13205 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13206 	{ 2, alc861_uniwill_m31_ch2_init },
13207 	{ 4, alc861_uniwill_m31_ch4_init },
13208 };
13209 
13210 /* Set mic1 and line-in as input and unmute the mixer */
13211 static struct hda_verb alc861_asus_ch2_init[] = {
13212 	/* set pin widget 1Ah (line in) for input */
13213 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13214 	/* set pin widget 18h (mic1/2) for input, for mic also enable
13215 	 * the vref
13216 	 */
13217 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13218 
13219 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13220 #if 0
13221 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13222 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13223 #endif
13224 	{ } /* end */
13225 };
13226 /* Set mic1 nad line-in as output and mute mixer */
13227 static struct hda_verb alc861_asus_ch6_init[] = {
13228 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
13229 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13230 	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13231 	/* set pin widget 18h (mic1) for output (CLFE)*/
13232 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13233 	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13234 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13235 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13236 
13237 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13238 #if 0
13239 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13240 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13241 #endif
13242 	{ } /* end */
13243 };
13244 
13245 static struct hda_channel_mode alc861_asus_modes[2] = {
13246 	{ 2, alc861_asus_ch2_init },
13247 	{ 6, alc861_asus_ch6_init },
13248 };
13249 
13250 /* patch-ALC861 */
13251 
13252 static struct snd_kcontrol_new alc861_base_mixer[] = {
13253         /* output mixer control */
13254 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13255 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13256 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13257 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13258 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13259 
13260         /*Input mixer control */
13261 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13262 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13263 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13264 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13265 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13266 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13267 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13268 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13269 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13270 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13271 
13272 	{ } /* end */
13273 };
13274 
13275 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13276         /* output mixer control */
13277 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13278 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13279 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13280 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13281 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13282 
13283 	/* Input mixer control */
13284 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13285 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13286 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13287 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13288 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13289 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13290 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13291 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13292 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13293 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13294 
13295 	{
13296 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13297 		.name = "Channel Mode",
13298 		.info = alc_ch_mode_info,
13299 		.get = alc_ch_mode_get,
13300 		.put = alc_ch_mode_put,
13301                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13302 	},
13303 	{ } /* end */
13304 };
13305 
13306 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13307         /* output mixer control */
13308 	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13309 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13310 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13311 
13312 	{ } /* end */
13313 };
13314 
13315 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13316         /* output mixer control */
13317 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13318 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13319 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13320 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13321 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13322 
13323 	/* Input mixer control */
13324 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13325 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13326 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13327 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13328 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13329 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13330 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13331 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13332 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13333 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13334 
13335 	{
13336 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13337 		.name = "Channel Mode",
13338 		.info = alc_ch_mode_info,
13339 		.get = alc_ch_mode_get,
13340 		.put = alc_ch_mode_put,
13341                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13342 	},
13343 	{ } /* end */
13344 };
13345 
13346 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13347         /* output mixer control */
13348 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13349 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13350 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13351 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13352 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13353 
13354 	/* Input mixer control */
13355 	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13356 	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13357 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13358 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13359 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13360 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13361 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13362 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13363 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13364 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13365 
13366 	{
13367 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13368 		.name = "Channel Mode",
13369 		.info = alc_ch_mode_info,
13370 		.get = alc_ch_mode_get,
13371 		.put = alc_ch_mode_put,
13372                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13373 	},
13374 	{ }
13375 };
13376 
13377 /* additional mixer */
13378 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13379 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13380 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13381 	{ }
13382 };
13383 
13384 /*
13385  * generic initialization of ADC, input mixers and output mixers
13386  */
13387 static struct hda_verb alc861_base_init_verbs[] = {
13388 	/*
13389 	 * Unmute ADC0 and set the default input to mic-in
13390 	 */
13391 	/* port-A for surround (rear panel) */
13392 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13393 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13394 	/* port-B for mic-in (rear panel) with vref */
13395 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13396 	/* port-C for line-in (rear panel) */
13397 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13398 	/* port-D for Front */
13399 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13400 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13401 	/* port-E for HP out (front panel) */
13402 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13403 	/* route front PCM to HP */
13404 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13405 	/* port-F for mic-in (front panel) with vref */
13406 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13407 	/* port-G for CLFE (rear panel) */
13408 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13409 	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13410 	/* port-H for side (rear panel) */
13411 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13412 	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13413 	/* CD-in */
13414 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13415 	/* route front mic to ADC1*/
13416 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13417 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13418 
13419 	/* Unmute DAC0~3 & spdif out*/
13420 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13421 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13422 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13423 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13424 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13425 
13426 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13427 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13428         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13429 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13430         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13431 
13432 	/* Unmute Stereo Mixer 15 */
13433 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13434 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13435 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13436 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13437 
13438 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13439 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13440 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13441 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13442 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13443 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13444 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13445 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13446 	/* hp used DAC 3 (Front) */
13447 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13448         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13449 
13450 	{ }
13451 };
13452 
13453 static struct hda_verb alc861_threestack_init_verbs[] = {
13454 	/*
13455 	 * Unmute ADC0 and set the default input to mic-in
13456 	 */
13457 	/* port-A for surround (rear panel) */
13458 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13459 	/* port-B for mic-in (rear panel) with vref */
13460 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13461 	/* port-C for line-in (rear panel) */
13462 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13463 	/* port-D for Front */
13464 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13465 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13466 	/* port-E for HP out (front panel) */
13467 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13468 	/* route front PCM to HP */
13469 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13470 	/* port-F for mic-in (front panel) with vref */
13471 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13472 	/* port-G for CLFE (rear panel) */
13473 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13474 	/* port-H for side (rear panel) */
13475 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13476 	/* CD-in */
13477 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13478 	/* route front mic to ADC1*/
13479 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13480 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13481 	/* Unmute DAC0~3 & spdif out*/
13482 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13483 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13484 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13485 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13486 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13487 
13488 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13489 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13490         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13491 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13492         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13493 
13494 	/* Unmute Stereo Mixer 15 */
13495 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13496 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13497 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13498 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13499 
13500 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13501 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13502 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13503 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13504 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13505 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13506 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13507 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13508 	/* hp used DAC 3 (Front) */
13509 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13510         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13511 	{ }
13512 };
13513 
13514 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13515 	/*
13516 	 * Unmute ADC0 and set the default input to mic-in
13517 	 */
13518 	/* port-A for surround (rear panel) */
13519 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13520 	/* port-B for mic-in (rear panel) with vref */
13521 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13522 	/* port-C for line-in (rear panel) */
13523 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13524 	/* port-D for Front */
13525 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13526 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13527 	/* port-E for HP out (front panel) */
13528 	/* this has to be set to VREF80 */
13529 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13530 	/* route front PCM to HP */
13531 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13532 	/* port-F for mic-in (front panel) with vref */
13533 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13534 	/* port-G for CLFE (rear panel) */
13535 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13536 	/* port-H for side (rear panel) */
13537 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13538 	/* CD-in */
13539 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13540 	/* route front mic to ADC1*/
13541 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13542 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13543 	/* Unmute DAC0~3 & spdif out*/
13544 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13545 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13546 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13547 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13548 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13549 
13550 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13551 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13552         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13553 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13554         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13555 
13556 	/* Unmute Stereo Mixer 15 */
13557 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13558 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13559 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13560 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13561 
13562 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13563 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13564 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13565 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13566 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13567 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13568 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13569 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13570 	/* hp used DAC 3 (Front) */
13571 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13572         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13573 	{ }
13574 };
13575 
13576 static struct hda_verb alc861_asus_init_verbs[] = {
13577 	/*
13578 	 * Unmute ADC0 and set the default input to mic-in
13579 	 */
13580 	/* port-A for surround (rear panel)
13581 	 * according to codec#0 this is the HP jack
13582 	 */
13583 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13584 	/* route front PCM to HP */
13585 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13586 	/* port-B for mic-in (rear panel) with vref */
13587 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13588 	/* port-C for line-in (rear panel) */
13589 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13590 	/* port-D for Front */
13591 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13592 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13593 	/* port-E for HP out (front panel) */
13594 	/* this has to be set to VREF80 */
13595 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13596 	/* route front PCM to HP */
13597 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13598 	/* port-F for mic-in (front panel) with vref */
13599 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13600 	/* port-G for CLFE (rear panel) */
13601 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13602 	/* port-H for side (rear panel) */
13603 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13604 	/* CD-in */
13605 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13606 	/* route front mic to ADC1*/
13607 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13608 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13609 	/* Unmute DAC0~3 & spdif out*/
13610 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13611 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13612 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13613 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13614 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13615 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13616 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13617         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13618 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13619         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13620 
13621 	/* Unmute Stereo Mixer 15 */
13622 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13623 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13624 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13625 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13626 
13627 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13628 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13629 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13630 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13631 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13632 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13633 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13634 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13635 	/* hp used DAC 3 (Front) */
13636 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13637 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13638 	{ }
13639 };
13640 
13641 /* additional init verbs for ASUS laptops */
13642 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13643 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13644 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13645 	{ }
13646 };
13647 
13648 /*
13649  * generic initialization of ADC, input mixers and output mixers
13650  */
13651 static struct hda_verb alc861_auto_init_verbs[] = {
13652 	/*
13653 	 * Unmute ADC0 and set the default input to mic-in
13654 	 */
13655 	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13656 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13657 
13658 	/* Unmute DAC0~3 & spdif out*/
13659 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13660 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13661 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13662 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13663 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13664 
13665 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13666 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13667 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13668 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13669 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13670 
13671 	/* Unmute Stereo Mixer 15 */
13672 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13673 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13674 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13675 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13676 
13677 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13678 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13679 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13680 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13681 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13682 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13683 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13684 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13685 
13686 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13687 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13688 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13689 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13690 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13691 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13692 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13693 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13694 
13695 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
13696 
13697 	{ }
13698 };
13699 
13700 static struct hda_verb alc861_toshiba_init_verbs[] = {
13701 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13702 
13703 	{ }
13704 };
13705 
13706 /* toggle speaker-output according to the hp-jack state */
13707 static void alc861_toshiba_automute(struct hda_codec *codec)
13708 {
13709 	unsigned int present;
13710 
13711 	present = snd_hda_codec_read(codec, 0x0f, 0,
13712 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13713 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13714 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13715 	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13716 				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13717 }
13718 
13719 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13720 				       unsigned int res)
13721 {
13722 	if ((res >> 26) == ALC880_HP_EVENT)
13723 		alc861_toshiba_automute(codec);
13724 }
13725 
13726 /* pcm configuration: identiacal with ALC880 */
13727 #define alc861_pcm_analog_playback	alc880_pcm_analog_playback
13728 #define alc861_pcm_analog_capture	alc880_pcm_analog_capture
13729 #define alc861_pcm_digital_playback	alc880_pcm_digital_playback
13730 #define alc861_pcm_digital_capture	alc880_pcm_digital_capture
13731 
13732 
13733 #define ALC861_DIGOUT_NID	0x07
13734 
13735 static struct hda_channel_mode alc861_8ch_modes[1] = {
13736 	{ 8, NULL }
13737 };
13738 
13739 static hda_nid_t alc861_dac_nids[4] = {
13740 	/* front, surround, clfe, side */
13741 	0x03, 0x06, 0x05, 0x04
13742 };
13743 
13744 static hda_nid_t alc660_dac_nids[3] = {
13745 	/* front, clfe, surround */
13746 	0x03, 0x05, 0x06
13747 };
13748 
13749 static hda_nid_t alc861_adc_nids[1] = {
13750 	/* ADC0-2 */
13751 	0x08,
13752 };
13753 
13754 static struct hda_input_mux alc861_capture_source = {
13755 	.num_items = 5,
13756 	.items = {
13757 		{ "Mic", 0x0 },
13758 		{ "Front Mic", 0x3 },
13759 		{ "Line", 0x1 },
13760 		{ "CD", 0x4 },
13761 		{ "Mixer", 0x5 },
13762 	},
13763 };
13764 
13765 /* fill in the dac_nids table from the parsed pin configuration */
13766 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13767 				     const struct auto_pin_cfg *cfg)
13768 {
13769 	int i;
13770 	hda_nid_t nid;
13771 
13772 	spec->multiout.dac_nids = spec->private_dac_nids;
13773 	for (i = 0; i < cfg->line_outs; i++) {
13774 		nid = cfg->line_out_pins[i];
13775 		if (nid) {
13776 			if (i >= ARRAY_SIZE(alc861_dac_nids))
13777 				continue;
13778 			spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13779 		}
13780 	}
13781 	spec->multiout.num_dacs = cfg->line_outs;
13782 	return 0;
13783 }
13784 
13785 /* add playback controls from the parsed DAC table */
13786 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13787 					     const struct auto_pin_cfg *cfg)
13788 {
13789 	char name[32];
13790 	static const char *chname[4] = {
13791 		"Front", "Surround", NULL /*CLFE*/, "Side"
13792 	};
13793 	hda_nid_t nid;
13794 	int i, idx, err;
13795 
13796 	for (i = 0; i < cfg->line_outs; i++) {
13797 		nid = spec->multiout.dac_nids[i];
13798 		if (!nid)
13799 			continue;
13800 		if (nid == 0x05) {
13801 			/* Center/LFE */
13802 			err = add_control(spec, ALC_CTL_BIND_MUTE,
13803 					  "Center Playback Switch",
13804 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13805 							      HDA_OUTPUT));
13806 			if (err < 0)
13807 				return err;
13808 			err = add_control(spec, ALC_CTL_BIND_MUTE,
13809 					  "LFE Playback Switch",
13810 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13811 							      HDA_OUTPUT));
13812 			if (err < 0)
13813 				return err;
13814 		} else {
13815 			for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13816 			     idx++)
13817 				if (nid == alc861_dac_nids[idx])
13818 					break;
13819 			sprintf(name, "%s Playback Switch", chname[idx]);
13820 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13821 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13822 							      HDA_OUTPUT));
13823 			if (err < 0)
13824 				return err;
13825 		}
13826 	}
13827 	return 0;
13828 }
13829 
13830 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13831 {
13832 	int err;
13833 	hda_nid_t nid;
13834 
13835 	if (!pin)
13836 		return 0;
13837 
13838 	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13839 		nid = 0x03;
13840 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13841 				  "Headphone Playback Switch",
13842 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13843 		if (err < 0)
13844 			return err;
13845 		spec->multiout.hp_nid = nid;
13846 	}
13847 	return 0;
13848 }
13849 
13850 /* create playback/capture controls for input pins */
13851 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13852 						const struct auto_pin_cfg *cfg)
13853 {
13854 	struct hda_input_mux *imux = &spec->private_imux[0];
13855 	int i, err, idx, idx1;
13856 
13857 	for (i = 0; i < AUTO_PIN_LAST; i++) {
13858 		switch (cfg->input_pins[i]) {
13859 		case 0x0c:
13860 			idx1 = 1;
13861 			idx = 2;	/* Line In */
13862 			break;
13863 		case 0x0f:
13864 			idx1 = 2;
13865 			idx = 2;	/* Line In */
13866 			break;
13867 		case 0x0d:
13868 			idx1 = 0;
13869 			idx = 1;	/* Mic In */
13870 			break;
13871 		case 0x10:
13872 			idx1 = 3;
13873 			idx = 1;	/* Mic In */
13874 			break;
13875 		case 0x11:
13876 			idx1 = 4;
13877 			idx = 0;	/* CD */
13878 			break;
13879 		default:
13880 			continue;
13881 		}
13882 
13883 		err = new_analog_input(spec, cfg->input_pins[i],
13884 				       auto_pin_cfg_labels[i], idx, 0x15);
13885 		if (err < 0)
13886 			return err;
13887 
13888 		imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13889 		imux->items[imux->num_items].index = idx1;
13890 		imux->num_items++;
13891 	}
13892 	return 0;
13893 }
13894 
13895 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13896 					      hda_nid_t nid,
13897 					      int pin_type, int dac_idx)
13898 {
13899 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13900 			    pin_type);
13901 	snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13902 			    AMP_OUT_UNMUTE);
13903 }
13904 
13905 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13906 {
13907 	struct alc_spec *spec = codec->spec;
13908 	int i;
13909 
13910 	alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13911 	for (i = 0; i < spec->autocfg.line_outs; i++) {
13912 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
13913 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
13914 		if (nid)
13915 			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13916 							  spec->multiout.dac_nids[i]);
13917 	}
13918 }
13919 
13920 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13921 {
13922 	struct alc_spec *spec = codec->spec;
13923 	hda_nid_t pin;
13924 
13925 	pin = spec->autocfg.hp_pins[0];
13926 	if (pin) /* connect to front */
13927 		alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13928 						  spec->multiout.dac_nids[0]);
13929 	pin = spec->autocfg.speaker_pins[0];
13930 	if (pin)
13931 		alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13932 }
13933 
13934 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13935 {
13936 	struct alc_spec *spec = codec->spec;
13937 	int i;
13938 
13939 	for (i = 0; i < AUTO_PIN_LAST; i++) {
13940 		hda_nid_t nid = spec->autocfg.input_pins[i];
13941 		if (nid >= 0x0c && nid <= 0x11)
13942 			alc_set_input_pin(codec, nid, i);
13943 	}
13944 }
13945 
13946 /* parse the BIOS configuration and set up the alc_spec */
13947 /* return 1 if successful, 0 if the proper config is not found,
13948  * or a negative error code
13949  */
13950 static int alc861_parse_auto_config(struct hda_codec *codec)
13951 {
13952 	struct alc_spec *spec = codec->spec;
13953 	int err;
13954 	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13955 
13956 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13957 					   alc861_ignore);
13958 	if (err < 0)
13959 		return err;
13960 	if (!spec->autocfg.line_outs)
13961 		return 0; /* can't find valid BIOS pin config */
13962 
13963 	err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13964 	if (err < 0)
13965 		return err;
13966 	err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13967 	if (err < 0)
13968 		return err;
13969 	err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13970 	if (err < 0)
13971 		return err;
13972 	err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13973 	if (err < 0)
13974 		return err;
13975 
13976 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13977 
13978 	if (spec->autocfg.dig_outs)
13979 		spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13980 
13981 	if (spec->kctls.list)
13982 		add_mixer(spec, spec->kctls.list);
13983 
13984 	add_verb(spec, alc861_auto_init_verbs);
13985 
13986 	spec->num_mux_defs = 1;
13987 	spec->input_mux = &spec->private_imux[0];
13988 
13989 	spec->adc_nids = alc861_adc_nids;
13990 	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13991 	set_capture_mixer(spec);
13992 
13993 	return 1;
13994 }
13995 
13996 /* additional initialization for auto-configuration model */
13997 static void alc861_auto_init(struct hda_codec *codec)
13998 {
13999 	struct alc_spec *spec = codec->spec;
14000 	alc861_auto_init_multi_out(codec);
14001 	alc861_auto_init_hp_out(codec);
14002 	alc861_auto_init_analog_input(codec);
14003 	if (spec->unsol_event)
14004 		alc_inithook(codec);
14005 }
14006 
14007 #ifdef CONFIG_SND_HDA_POWER_SAVE
14008 static struct hda_amp_list alc861_loopbacks[] = {
14009 	{ 0x15, HDA_INPUT, 0 },
14010 	{ 0x15, HDA_INPUT, 1 },
14011 	{ 0x15, HDA_INPUT, 2 },
14012 	{ 0x15, HDA_INPUT, 3 },
14013 	{ } /* end */
14014 };
14015 #endif
14016 
14017 
14018 /*
14019  * configuration and preset
14020  */
14021 static const char *alc861_models[ALC861_MODEL_LAST] = {
14022 	[ALC861_3ST]		= "3stack",
14023 	[ALC660_3ST]		= "3stack-660",
14024 	[ALC861_3ST_DIG]	= "3stack-dig",
14025 	[ALC861_6ST_DIG]	= "6stack-dig",
14026 	[ALC861_UNIWILL_M31]	= "uniwill-m31",
14027 	[ALC861_TOSHIBA]	= "toshiba",
14028 	[ALC861_ASUS]		= "asus",
14029 	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
14030 	[ALC861_AUTO]		= "auto",
14031 };
14032 
14033 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14034 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14035 	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14036 	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14037 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14038 	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14039 	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14040 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14041 	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14042 	 *        Any other models that need this preset?
14043 	 */
14044 	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14045 	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14046 	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14047 	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14048 	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14049 	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14050 	/* FIXME: the below seems conflict */
14051 	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14052 	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14053 	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14054 	{}
14055 };
14056 
14057 static struct alc_config_preset alc861_presets[] = {
14058 	[ALC861_3ST] = {
14059 		.mixers = { alc861_3ST_mixer },
14060 		.init_verbs = { alc861_threestack_init_verbs },
14061 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14062 		.dac_nids = alc861_dac_nids,
14063 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14064 		.channel_mode = alc861_threestack_modes,
14065 		.need_dac_fix = 1,
14066 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14067 		.adc_nids = alc861_adc_nids,
14068 		.input_mux = &alc861_capture_source,
14069 	},
14070 	[ALC861_3ST_DIG] = {
14071 		.mixers = { alc861_base_mixer },
14072 		.init_verbs = { alc861_threestack_init_verbs },
14073 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14074 		.dac_nids = alc861_dac_nids,
14075 		.dig_out_nid = ALC861_DIGOUT_NID,
14076 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14077 		.channel_mode = alc861_threestack_modes,
14078 		.need_dac_fix = 1,
14079 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14080 		.adc_nids = alc861_adc_nids,
14081 		.input_mux = &alc861_capture_source,
14082 	},
14083 	[ALC861_6ST_DIG] = {
14084 		.mixers = { alc861_base_mixer },
14085 		.init_verbs = { alc861_base_init_verbs },
14086 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14087 		.dac_nids = alc861_dac_nids,
14088 		.dig_out_nid = ALC861_DIGOUT_NID,
14089 		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14090 		.channel_mode = alc861_8ch_modes,
14091 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14092 		.adc_nids = alc861_adc_nids,
14093 		.input_mux = &alc861_capture_source,
14094 	},
14095 	[ALC660_3ST] = {
14096 		.mixers = { alc861_3ST_mixer },
14097 		.init_verbs = { alc861_threestack_init_verbs },
14098 		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
14099 		.dac_nids = alc660_dac_nids,
14100 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14101 		.channel_mode = alc861_threestack_modes,
14102 		.need_dac_fix = 1,
14103 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14104 		.adc_nids = alc861_adc_nids,
14105 		.input_mux = &alc861_capture_source,
14106 	},
14107 	[ALC861_UNIWILL_M31] = {
14108 		.mixers = { alc861_uniwill_m31_mixer },
14109 		.init_verbs = { alc861_uniwill_m31_init_verbs },
14110 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14111 		.dac_nids = alc861_dac_nids,
14112 		.dig_out_nid = ALC861_DIGOUT_NID,
14113 		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14114 		.channel_mode = alc861_uniwill_m31_modes,
14115 		.need_dac_fix = 1,
14116 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14117 		.adc_nids = alc861_adc_nids,
14118 		.input_mux = &alc861_capture_source,
14119 	},
14120 	[ALC861_TOSHIBA] = {
14121 		.mixers = { alc861_toshiba_mixer },
14122 		.init_verbs = { alc861_base_init_verbs,
14123 				alc861_toshiba_init_verbs },
14124 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14125 		.dac_nids = alc861_dac_nids,
14126 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14127 		.channel_mode = alc883_3ST_2ch_modes,
14128 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14129 		.adc_nids = alc861_adc_nids,
14130 		.input_mux = &alc861_capture_source,
14131 		.unsol_event = alc861_toshiba_unsol_event,
14132 		.init_hook = alc861_toshiba_automute,
14133 	},
14134 	[ALC861_ASUS] = {
14135 		.mixers = { alc861_asus_mixer },
14136 		.init_verbs = { alc861_asus_init_verbs },
14137 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14138 		.dac_nids = alc861_dac_nids,
14139 		.dig_out_nid = ALC861_DIGOUT_NID,
14140 		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14141 		.channel_mode = alc861_asus_modes,
14142 		.need_dac_fix = 1,
14143 		.hp_nid = 0x06,
14144 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14145 		.adc_nids = alc861_adc_nids,
14146 		.input_mux = &alc861_capture_source,
14147 	},
14148 	[ALC861_ASUS_LAPTOP] = {
14149 		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14150 		.init_verbs = { alc861_asus_init_verbs,
14151 				alc861_asus_laptop_init_verbs },
14152 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14153 		.dac_nids = alc861_dac_nids,
14154 		.dig_out_nid = ALC861_DIGOUT_NID,
14155 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14156 		.channel_mode = alc883_3ST_2ch_modes,
14157 		.need_dac_fix = 1,
14158 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14159 		.adc_nids = alc861_adc_nids,
14160 		.input_mux = &alc861_capture_source,
14161 	},
14162 };
14163 
14164 
14165 static int patch_alc861(struct hda_codec *codec)
14166 {
14167 	struct alc_spec *spec;
14168 	int board_config;
14169 	int err;
14170 
14171 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14172 	if (spec == NULL)
14173 		return -ENOMEM;
14174 
14175 	codec->spec = spec;
14176 
14177         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14178 						  alc861_models,
14179 						  alc861_cfg_tbl);
14180 
14181 	if (board_config < 0) {
14182 		printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
14183 		       "trying auto-probe from BIOS...\n");
14184 		board_config = ALC861_AUTO;
14185 	}
14186 
14187 	if (board_config == ALC861_AUTO) {
14188 		/* automatic parse from the BIOS config */
14189 		err = alc861_parse_auto_config(codec);
14190 		if (err < 0) {
14191 			alc_free(codec);
14192 			return err;
14193 		} else if (!err) {
14194 			printk(KERN_INFO
14195 			       "hda_codec: Cannot set up configuration "
14196 			       "from BIOS.  Using base mode...\n");
14197 		   board_config = ALC861_3ST_DIG;
14198 		}
14199 	}
14200 
14201 	err = snd_hda_attach_beep_device(codec, 0x23);
14202 	if (err < 0) {
14203 		alc_free(codec);
14204 		return err;
14205 	}
14206 
14207 	if (board_config != ALC861_AUTO)
14208 		setup_preset(spec, &alc861_presets[board_config]);
14209 
14210 	spec->stream_name_analog = "ALC861 Analog";
14211 	spec->stream_analog_playback = &alc861_pcm_analog_playback;
14212 	spec->stream_analog_capture = &alc861_pcm_analog_capture;
14213 
14214 	spec->stream_name_digital = "ALC861 Digital";
14215 	spec->stream_digital_playback = &alc861_pcm_digital_playback;
14216 	spec->stream_digital_capture = &alc861_pcm_digital_capture;
14217 
14218 	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14219 
14220 	spec->vmaster_nid = 0x03;
14221 
14222 	codec->patch_ops = alc_patch_ops;
14223 	if (board_config == ALC861_AUTO)
14224 		spec->init_hook = alc861_auto_init;
14225 #ifdef CONFIG_SND_HDA_POWER_SAVE
14226 	if (!spec->loopback.amplist)
14227 		spec->loopback.amplist = alc861_loopbacks;
14228 #endif
14229 	codec->proc_widget_hook = print_realtek_coef;
14230 
14231 	return 0;
14232 }
14233 
14234 /*
14235  * ALC861-VD support
14236  *
14237  * Based on ALC882
14238  *
14239  * In addition, an independent DAC
14240  */
14241 #define ALC861VD_DIGOUT_NID	0x06
14242 
14243 static hda_nid_t alc861vd_dac_nids[4] = {
14244 	/* front, surr, clfe, side surr */
14245 	0x02, 0x03, 0x04, 0x05
14246 };
14247 
14248 /* dac_nids for ALC660vd are in a different order - according to
14249  * Realtek's driver.
14250  * This should probably tesult in a different mixer for 6stack models
14251  * of ALC660vd codecs, but for now there is only 3stack mixer
14252  * - and it is the same as in 861vd.
14253  * adc_nids in ALC660vd are (is) the same as in 861vd
14254  */
14255 static hda_nid_t alc660vd_dac_nids[3] = {
14256 	/* front, rear, clfe, rear_surr */
14257 	0x02, 0x04, 0x03
14258 };
14259 
14260 static hda_nid_t alc861vd_adc_nids[1] = {
14261 	/* ADC0 */
14262 	0x09,
14263 };
14264 
14265 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14266 
14267 /* input MUX */
14268 /* FIXME: should be a matrix-type input source selection */
14269 static struct hda_input_mux alc861vd_capture_source = {
14270 	.num_items = 4,
14271 	.items = {
14272 		{ "Mic", 0x0 },
14273 		{ "Front Mic", 0x1 },
14274 		{ "Line", 0x2 },
14275 		{ "CD", 0x4 },
14276 	},
14277 };
14278 
14279 static struct hda_input_mux alc861vd_dallas_capture_source = {
14280 	.num_items = 2,
14281 	.items = {
14282 		{ "Ext Mic", 0x0 },
14283 		{ "Int Mic", 0x1 },
14284 	},
14285 };
14286 
14287 static struct hda_input_mux alc861vd_hp_capture_source = {
14288 	.num_items = 2,
14289 	.items = {
14290 		{ "Front Mic", 0x0 },
14291 		{ "ATAPI Mic", 0x1 },
14292 	},
14293 };
14294 
14295 /*
14296  * 2ch mode
14297  */
14298 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14299 	{ 2, NULL }
14300 };
14301 
14302 /*
14303  * 6ch mode
14304  */
14305 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14306 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14307 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14308 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14309 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14310 	{ } /* end */
14311 };
14312 
14313 /*
14314  * 8ch mode
14315  */
14316 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14317 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14318 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14319 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14320 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14321 	{ } /* end */
14322 };
14323 
14324 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14325 	{ 6, alc861vd_6stack_ch6_init },
14326 	{ 8, alc861vd_6stack_ch8_init },
14327 };
14328 
14329 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14330 	{
14331 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14332 		.name = "Channel Mode",
14333 		.info = alc_ch_mode_info,
14334 		.get = alc_ch_mode_get,
14335 		.put = alc_ch_mode_put,
14336 	},
14337 	{ } /* end */
14338 };
14339 
14340 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14341  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14342  */
14343 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14344 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14345 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14346 
14347 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14348 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14349 
14350 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14351 				HDA_OUTPUT),
14352 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14353 				HDA_OUTPUT),
14354 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14355 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14356 
14357 	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14358 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14359 
14360 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14361 
14362 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14363 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14364 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14365 
14366 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14367 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14368 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14369 
14370 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14371 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14372 
14373 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14374 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14375 
14376 	{ } /* end */
14377 };
14378 
14379 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14380 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14381 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14382 
14383 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14384 
14385 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14386 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14387 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14388 
14389 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14390 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14391 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14392 
14393 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14394 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14395 
14396 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14397 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14398 
14399 	{ } /* end */
14400 };
14401 
14402 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14403 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14404 	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14405 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14406 
14407 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14408 
14409 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14410 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14411 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14412 
14413 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14414 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14415 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14416 
14417 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14418 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14419 
14420 	{ } /* end */
14421 };
14422 
14423 /* Pin assignment: Speaker=0x14, HP = 0x15,
14424  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14425  */
14426 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14427 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14428 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14429 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14430 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14431 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14432 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14433 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14434 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14435 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14436 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14437 	{ } /* end */
14438 };
14439 
14440 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14441  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14442  */
14443 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14444 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14445 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14446 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14447 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14448 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14449 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14450 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14451 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14452 
14453 	{ } /* end */
14454 };
14455 
14456 /*
14457  * generic initialization of ADC, input mixers and output mixers
14458  */
14459 static struct hda_verb alc861vd_volume_init_verbs[] = {
14460 	/*
14461 	 * Unmute ADC0 and set the default input to mic-in
14462 	 */
14463 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14464 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14465 
14466 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14467 	 * the analog-loopback mixer widget
14468 	 */
14469 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14470 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14471 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14472 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14473 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14474 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14475 
14476 	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14477 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14478 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14479 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14480 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14481 
14482 	/*
14483 	 * Set up output mixers (0x02 - 0x05)
14484 	 */
14485 	/* set vol=0 to output mixers */
14486 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14487 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14488 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14489 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14490 
14491 	/* set up input amps for analog loopback */
14492 	/* Amp Indices: DAC = 0, mixer = 1 */
14493 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14494 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14495 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14496 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14497 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14498 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14499 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14500 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14501 
14502 	{ }
14503 };
14504 
14505 /*
14506  * 3-stack pin configuration:
14507  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14508  */
14509 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14510 	/*
14511 	 * Set pin mode and muting
14512 	 */
14513 	/* set front pin widgets 0x14 for output */
14514 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14515 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14516 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14517 
14518 	/* Mic (rear) pin: input vref at 80% */
14519 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14520 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14521 	/* Front Mic pin: input vref at 80% */
14522 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14523 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14524 	/* Line In pin: input */
14525 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14526 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14527 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
14528 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14529 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14530 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14531 	/* CD pin widget for input */
14532 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14533 
14534 	{ }
14535 };
14536 
14537 /*
14538  * 6-stack pin configuration:
14539  */
14540 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14541 	/*
14542 	 * Set pin mode and muting
14543 	 */
14544 	/* set front pin widgets 0x14 for output */
14545 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14546 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14547 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14548 
14549 	/* Rear Pin: output 1 (0x0d) */
14550 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14551 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14552 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14553 	/* CLFE Pin: output 2 (0x0e) */
14554 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14555 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14556 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14557 	/* Side Pin: output 3 (0x0f) */
14558 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14559 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14560 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14561 
14562 	/* Mic (rear) pin: input vref at 80% */
14563 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14564 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14565 	/* Front Mic pin: input vref at 80% */
14566 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14567 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14568 	/* Line In pin: input */
14569 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14570 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14571 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
14572 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14573 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14574 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14575 	/* CD pin widget for input */
14576 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14577 
14578 	{ }
14579 };
14580 
14581 static struct hda_verb alc861vd_eapd_verbs[] = {
14582 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14583 	{ }
14584 };
14585 
14586 static struct hda_verb alc660vd_eapd_verbs[] = {
14587 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14588 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14589 	{ }
14590 };
14591 
14592 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14593 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14594 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14595 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14596 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14597 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14598 	{}
14599 };
14600 
14601 /* toggle speaker-output according to the hp-jack state */
14602 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14603 {
14604 	unsigned int present;
14605 	unsigned char bits;
14606 
14607 	present = snd_hda_codec_read(codec, 0x1b, 0,
14608 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14609 	bits = present ? HDA_AMP_MUTE : 0;
14610 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14611 				 HDA_AMP_MUTE, bits);
14612 }
14613 
14614 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14615 {
14616 	unsigned int present;
14617 	unsigned char bits;
14618 
14619 	present = snd_hda_codec_read(codec, 0x18, 0,
14620 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14621 	bits = present ? HDA_AMP_MUTE : 0;
14622 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14623 				 HDA_AMP_MUTE, bits);
14624 }
14625 
14626 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14627 {
14628 	alc861vd_lenovo_hp_automute(codec);
14629 	alc861vd_lenovo_mic_automute(codec);
14630 }
14631 
14632 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14633 					unsigned int res)
14634 {
14635 	switch (res >> 26) {
14636 	case ALC880_HP_EVENT:
14637 		alc861vd_lenovo_hp_automute(codec);
14638 		break;
14639 	case ALC880_MIC_EVENT:
14640 		alc861vd_lenovo_mic_automute(codec);
14641 		break;
14642 	}
14643 }
14644 
14645 static struct hda_verb alc861vd_dallas_verbs[] = {
14646 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14647 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14648 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14649 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14650 
14651 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14652 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14653 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14654 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14655 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14656 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14657 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14658 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14659 
14660 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14661 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14662 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14663 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14664 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14665 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14666 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14667 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14668 
14669 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14670 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14671 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14672 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14673 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14674 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14675 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14676 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14677 
14678 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14679 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14680 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14681 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14682 
14683 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14684 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14685 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14686 
14687 	{ } /* end */
14688 };
14689 
14690 /* toggle speaker-output according to the hp-jack state */
14691 static void alc861vd_dallas_automute(struct hda_codec *codec)
14692 {
14693 	unsigned int present;
14694 
14695 	present = snd_hda_codec_read(codec, 0x15, 0,
14696 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14697 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14698 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14699 }
14700 
14701 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14702 {
14703 	if ((res >> 26) == ALC880_HP_EVENT)
14704 		alc861vd_dallas_automute(codec);
14705 }
14706 
14707 #ifdef CONFIG_SND_HDA_POWER_SAVE
14708 #define alc861vd_loopbacks	alc880_loopbacks
14709 #endif
14710 
14711 /* pcm configuration: identiacal with ALC880 */
14712 #define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
14713 #define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
14714 #define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
14715 #define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
14716 
14717 /*
14718  * configuration and preset
14719  */
14720 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14721 	[ALC660VD_3ST]		= "3stack-660",
14722 	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
14723 	[ALC660VD_ASUS_V1S]	= "asus-v1s",
14724 	[ALC861VD_3ST]		= "3stack",
14725 	[ALC861VD_3ST_DIG]	= "3stack-digout",
14726 	[ALC861VD_6ST_DIG]	= "6stack-digout",
14727 	[ALC861VD_LENOVO]	= "lenovo",
14728 	[ALC861VD_DALLAS]	= "dallas",
14729 	[ALC861VD_HP]		= "hp",
14730 	[ALC861VD_AUTO]		= "auto",
14731 };
14732 
14733 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14734 	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14735 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14736 	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14737 	SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14738 	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14739 	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14740 	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14741 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14742 	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14743 	SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14744 	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14745 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14746 	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14747 	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14748 	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14749 	{}
14750 };
14751 
14752 static struct alc_config_preset alc861vd_presets[] = {
14753 	[ALC660VD_3ST] = {
14754 		.mixers = { alc861vd_3st_mixer },
14755 		.init_verbs = { alc861vd_volume_init_verbs,
14756 				 alc861vd_3stack_init_verbs },
14757 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14758 		.dac_nids = alc660vd_dac_nids,
14759 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14760 		.channel_mode = alc861vd_3stack_2ch_modes,
14761 		.input_mux = &alc861vd_capture_source,
14762 	},
14763 	[ALC660VD_3ST_DIG] = {
14764 		.mixers = { alc861vd_3st_mixer },
14765 		.init_verbs = { alc861vd_volume_init_verbs,
14766 				 alc861vd_3stack_init_verbs },
14767 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14768 		.dac_nids = alc660vd_dac_nids,
14769 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14770 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14771 		.channel_mode = alc861vd_3stack_2ch_modes,
14772 		.input_mux = &alc861vd_capture_source,
14773 	},
14774 	[ALC861VD_3ST] = {
14775 		.mixers = { alc861vd_3st_mixer },
14776 		.init_verbs = { alc861vd_volume_init_verbs,
14777 				 alc861vd_3stack_init_verbs },
14778 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14779 		.dac_nids = alc861vd_dac_nids,
14780 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14781 		.channel_mode = alc861vd_3stack_2ch_modes,
14782 		.input_mux = &alc861vd_capture_source,
14783 	},
14784 	[ALC861VD_3ST_DIG] = {
14785 		.mixers = { alc861vd_3st_mixer },
14786 		.init_verbs = { alc861vd_volume_init_verbs,
14787 		 		 alc861vd_3stack_init_verbs },
14788 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14789 		.dac_nids = alc861vd_dac_nids,
14790 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14791 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14792 		.channel_mode = alc861vd_3stack_2ch_modes,
14793 		.input_mux = &alc861vd_capture_source,
14794 	},
14795 	[ALC861VD_6ST_DIG] = {
14796 		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14797 		.init_verbs = { alc861vd_volume_init_verbs,
14798 				alc861vd_6stack_init_verbs },
14799 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14800 		.dac_nids = alc861vd_dac_nids,
14801 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14802 		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14803 		.channel_mode = alc861vd_6stack_modes,
14804 		.input_mux = &alc861vd_capture_source,
14805 	},
14806 	[ALC861VD_LENOVO] = {
14807 		.mixers = { alc861vd_lenovo_mixer },
14808 		.init_verbs = { alc861vd_volume_init_verbs,
14809 				alc861vd_3stack_init_verbs,
14810 				alc861vd_eapd_verbs,
14811 				alc861vd_lenovo_unsol_verbs },
14812 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14813 		.dac_nids = alc660vd_dac_nids,
14814 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14815 		.channel_mode = alc861vd_3stack_2ch_modes,
14816 		.input_mux = &alc861vd_capture_source,
14817 		.unsol_event = alc861vd_lenovo_unsol_event,
14818 		.init_hook = alc861vd_lenovo_automute,
14819 	},
14820 	[ALC861VD_DALLAS] = {
14821 		.mixers = { alc861vd_dallas_mixer },
14822 		.init_verbs = { alc861vd_dallas_verbs },
14823 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14824 		.dac_nids = alc861vd_dac_nids,
14825 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14826 		.channel_mode = alc861vd_3stack_2ch_modes,
14827 		.input_mux = &alc861vd_dallas_capture_source,
14828 		.unsol_event = alc861vd_dallas_unsol_event,
14829 		.init_hook = alc861vd_dallas_automute,
14830 	},
14831 	[ALC861VD_HP] = {
14832 		.mixers = { alc861vd_hp_mixer },
14833 		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14834 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14835 		.dac_nids = alc861vd_dac_nids,
14836 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14837 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14838 		.channel_mode = alc861vd_3stack_2ch_modes,
14839 		.input_mux = &alc861vd_hp_capture_source,
14840 		.unsol_event = alc861vd_dallas_unsol_event,
14841 		.init_hook = alc861vd_dallas_automute,
14842 	},
14843 	[ALC660VD_ASUS_V1S] = {
14844 		.mixers = { alc861vd_lenovo_mixer },
14845 		.init_verbs = { alc861vd_volume_init_verbs,
14846 				alc861vd_3stack_init_verbs,
14847 				alc861vd_eapd_verbs,
14848 				alc861vd_lenovo_unsol_verbs },
14849 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14850 		.dac_nids = alc660vd_dac_nids,
14851 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14852 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14853 		.channel_mode = alc861vd_3stack_2ch_modes,
14854 		.input_mux = &alc861vd_capture_source,
14855 		.unsol_event = alc861vd_lenovo_unsol_event,
14856 		.init_hook = alc861vd_lenovo_automute,
14857 	},
14858 };
14859 
14860 /*
14861  * BIOS auto configuration
14862  */
14863 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14864 				hda_nid_t nid, int pin_type, int dac_idx)
14865 {
14866 	alc_set_pin_output(codec, nid, pin_type);
14867 }
14868 
14869 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14870 {
14871 	struct alc_spec *spec = codec->spec;
14872 	int i;
14873 
14874 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14875 	for (i = 0; i <= HDA_SIDE; i++) {
14876 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
14877 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
14878 		if (nid)
14879 			alc861vd_auto_set_output_and_unmute(codec, nid,
14880 							    pin_type, i);
14881 	}
14882 }
14883 
14884 
14885 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14886 {
14887 	struct alc_spec *spec = codec->spec;
14888 	hda_nid_t pin;
14889 
14890 	pin = spec->autocfg.hp_pins[0];
14891 	if (pin) /* connect to front and  use dac 0 */
14892 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14893 	pin = spec->autocfg.speaker_pins[0];
14894 	if (pin)
14895 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14896 }
14897 
14898 #define alc861vd_is_input_pin(nid)	alc880_is_input_pin(nid)
14899 #define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
14900 
14901 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14902 {
14903 	struct alc_spec *spec = codec->spec;
14904 	int i;
14905 
14906 	for (i = 0; i < AUTO_PIN_LAST; i++) {
14907 		hda_nid_t nid = spec->autocfg.input_pins[i];
14908 		if (alc861vd_is_input_pin(nid)) {
14909 			alc_set_input_pin(codec, nid, i);
14910 			if (nid != ALC861VD_PIN_CD_NID &&
14911 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14912 				snd_hda_codec_write(codec, nid, 0,
14913 						AC_VERB_SET_AMP_GAIN_MUTE,
14914 						AMP_OUT_MUTE);
14915 		}
14916 	}
14917 }
14918 
14919 #define alc861vd_auto_init_input_src	alc882_auto_init_input_src
14920 
14921 #define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
14922 #define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
14923 
14924 /* add playback controls from the parsed DAC table */
14925 /* Based on ALC880 version. But ALC861VD has separate,
14926  * different NIDs for mute/unmute switch and volume control */
14927 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14928 					     const struct auto_pin_cfg *cfg)
14929 {
14930 	char name[32];
14931 	static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14932 	hda_nid_t nid_v, nid_s;
14933 	int i, err;
14934 
14935 	for (i = 0; i < cfg->line_outs; i++) {
14936 		if (!spec->multiout.dac_nids[i])
14937 			continue;
14938 		nid_v = alc861vd_idx_to_mixer_vol(
14939 				alc880_dac_to_idx(
14940 					spec->multiout.dac_nids[i]));
14941 		nid_s = alc861vd_idx_to_mixer_switch(
14942 				alc880_dac_to_idx(
14943 					spec->multiout.dac_nids[i]));
14944 
14945 		if (i == 2) {
14946 			/* Center/LFE */
14947 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
14948 					  "Center Playback Volume",
14949 					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14950 							      HDA_OUTPUT));
14951 			if (err < 0)
14952 				return err;
14953 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
14954 					  "LFE Playback Volume",
14955 					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14956 							      HDA_OUTPUT));
14957 			if (err < 0)
14958 				return err;
14959 			err = add_control(spec, ALC_CTL_BIND_MUTE,
14960 					  "Center Playback Switch",
14961 					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14962 							      HDA_INPUT));
14963 			if (err < 0)
14964 				return err;
14965 			err = add_control(spec, ALC_CTL_BIND_MUTE,
14966 					  "LFE Playback Switch",
14967 					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14968 							      HDA_INPUT));
14969 			if (err < 0)
14970 				return err;
14971 		} else {
14972 			sprintf(name, "%s Playback Volume", chname[i]);
14973 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14974 					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14975 							      HDA_OUTPUT));
14976 			if (err < 0)
14977 				return err;
14978 			sprintf(name, "%s Playback Switch", chname[i]);
14979 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14980 					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14981 							      HDA_INPUT));
14982 			if (err < 0)
14983 				return err;
14984 		}
14985 	}
14986 	return 0;
14987 }
14988 
14989 /* add playback controls for speaker and HP outputs */
14990 /* Based on ALC880 version. But ALC861VD has separate,
14991  * different NIDs for mute/unmute switch and volume control */
14992 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14993 					hda_nid_t pin, const char *pfx)
14994 {
14995 	hda_nid_t nid_v, nid_s;
14996 	int err;
14997 	char name[32];
14998 
14999 	if (!pin)
15000 		return 0;
15001 
15002 	if (alc880_is_fixed_pin(pin)) {
15003 		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15004 		/* specify the DAC as the extra output */
15005 		if (!spec->multiout.hp_nid)
15006 			spec->multiout.hp_nid = nid_v;
15007 		else
15008 			spec->multiout.extra_out_nid[0] = nid_v;
15009 		/* control HP volume/switch on the output mixer amp */
15010 		nid_v = alc861vd_idx_to_mixer_vol(
15011 				alc880_fixed_pin_idx(pin));
15012 		nid_s = alc861vd_idx_to_mixer_switch(
15013 				alc880_fixed_pin_idx(pin));
15014 
15015 		sprintf(name, "%s Playback Volume", pfx);
15016 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15017 				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15018 		if (err < 0)
15019 			return err;
15020 		sprintf(name, "%s Playback Switch", pfx);
15021 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15022 				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15023 		if (err < 0)
15024 			return err;
15025 	} else if (alc880_is_multi_pin(pin)) {
15026 		/* set manual connection */
15027 		/* we have only a switch on HP-out PIN */
15028 		sprintf(name, "%s Playback Switch", pfx);
15029 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15030 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15031 		if (err < 0)
15032 			return err;
15033 	}
15034 	return 0;
15035 }
15036 
15037 /* parse the BIOS configuration and set up the alc_spec
15038  * return 1 if successful, 0 if the proper config is not found,
15039  * or a negative error code
15040  * Based on ALC880 version - had to change it to override
15041  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15042 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15043 {
15044 	struct alc_spec *spec = codec->spec;
15045 	int err;
15046 	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15047 
15048 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15049 					   alc861vd_ignore);
15050 	if (err < 0)
15051 		return err;
15052 	if (!spec->autocfg.line_outs)
15053 		return 0; /* can't find valid BIOS pin config */
15054 
15055 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15056 	if (err < 0)
15057 		return err;
15058 	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15059 	if (err < 0)
15060 		return err;
15061 	err = alc861vd_auto_create_extra_out(spec,
15062 					     spec->autocfg.speaker_pins[0],
15063 					     "Speaker");
15064 	if (err < 0)
15065 		return err;
15066 	err = alc861vd_auto_create_extra_out(spec,
15067 					     spec->autocfg.hp_pins[0],
15068 					     "Headphone");
15069 	if (err < 0)
15070 		return err;
15071 	err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15072 	if (err < 0)
15073 		return err;
15074 
15075 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15076 
15077 	if (spec->autocfg.dig_outs)
15078 		spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15079 
15080 	if (spec->kctls.list)
15081 		add_mixer(spec, spec->kctls.list);
15082 
15083 	add_verb(spec, alc861vd_volume_init_verbs);
15084 
15085 	spec->num_mux_defs = 1;
15086 	spec->input_mux = &spec->private_imux[0];
15087 
15088 	err = alc_auto_add_mic_boost(codec);
15089 	if (err < 0)
15090 		return err;
15091 
15092 	return 1;
15093 }
15094 
15095 /* additional initialization for auto-configuration model */
15096 static void alc861vd_auto_init(struct hda_codec *codec)
15097 {
15098 	struct alc_spec *spec = codec->spec;
15099 	alc861vd_auto_init_multi_out(codec);
15100 	alc861vd_auto_init_hp_out(codec);
15101 	alc861vd_auto_init_analog_input(codec);
15102 	alc861vd_auto_init_input_src(codec);
15103 	if (spec->unsol_event)
15104 		alc_inithook(codec);
15105 }
15106 
15107 static int patch_alc861vd(struct hda_codec *codec)
15108 {
15109 	struct alc_spec *spec;
15110 	int err, board_config;
15111 
15112 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15113 	if (spec == NULL)
15114 		return -ENOMEM;
15115 
15116 	codec->spec = spec;
15117 
15118 	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15119 						  alc861vd_models,
15120 						  alc861vd_cfg_tbl);
15121 
15122 	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15123 		printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
15124 			"ALC861VD, trying auto-probe from BIOS...\n");
15125 		board_config = ALC861VD_AUTO;
15126 	}
15127 
15128 	if (board_config == ALC861VD_AUTO) {
15129 		/* automatic parse from the BIOS config */
15130 		err = alc861vd_parse_auto_config(codec);
15131 		if (err < 0) {
15132 			alc_free(codec);
15133 			return err;
15134 		} else if (!err) {
15135 			printk(KERN_INFO
15136 			       "hda_codec: Cannot set up configuration "
15137 			       "from BIOS.  Using base mode...\n");
15138 			board_config = ALC861VD_3ST;
15139 		}
15140 	}
15141 
15142 	err = snd_hda_attach_beep_device(codec, 0x23);
15143 	if (err < 0) {
15144 		alc_free(codec);
15145 		return err;
15146 	}
15147 
15148 	if (board_config != ALC861VD_AUTO)
15149 		setup_preset(spec, &alc861vd_presets[board_config]);
15150 
15151 	if (codec->vendor_id == 0x10ec0660) {
15152 		spec->stream_name_analog = "ALC660-VD Analog";
15153 		spec->stream_name_digital = "ALC660-VD Digital";
15154 		/* always turn on EAPD */
15155 		add_verb(spec, alc660vd_eapd_verbs);
15156 	} else {
15157 		spec->stream_name_analog = "ALC861VD Analog";
15158 		spec->stream_name_digital = "ALC861VD Digital";
15159 	}
15160 
15161 	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15162 	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15163 
15164 	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15165 	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15166 
15167 	spec->adc_nids = alc861vd_adc_nids;
15168 	spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15169 	spec->capsrc_nids = alc861vd_capsrc_nids;
15170 	spec->capture_style = CAPT_MIX;
15171 
15172 	set_capture_mixer(spec);
15173 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15174 
15175 	spec->vmaster_nid = 0x02;
15176 
15177 	codec->patch_ops = alc_patch_ops;
15178 
15179 	if (board_config == ALC861VD_AUTO)
15180 		spec->init_hook = alc861vd_auto_init;
15181 #ifdef CONFIG_SND_HDA_POWER_SAVE
15182 	if (!spec->loopback.amplist)
15183 		spec->loopback.amplist = alc861vd_loopbacks;
15184 #endif
15185 	codec->proc_widget_hook = print_realtek_coef;
15186 
15187 	return 0;
15188 }
15189 
15190 /*
15191  * ALC662 support
15192  *
15193  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15194  * configuration.  Each pin widget can choose any input DACs and a mixer.
15195  * Each ADC is connected from a mixer of all inputs.  This makes possible
15196  * 6-channel independent captures.
15197  *
15198  * In addition, an independent DAC for the multi-playback (not used in this
15199  * driver yet).
15200  */
15201 #define ALC662_DIGOUT_NID	0x06
15202 #define ALC662_DIGIN_NID	0x0a
15203 
15204 static hda_nid_t alc662_dac_nids[4] = {
15205 	/* front, rear, clfe, rear_surr */
15206 	0x02, 0x03, 0x04
15207 };
15208 
15209 static hda_nid_t alc662_adc_nids[1] = {
15210 	/* ADC1-2 */
15211 	0x09,
15212 };
15213 
15214 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15215 
15216 /* input MUX */
15217 /* FIXME: should be a matrix-type input source selection */
15218 static struct hda_input_mux alc662_capture_source = {
15219 	.num_items = 4,
15220 	.items = {
15221 		{ "Mic", 0x0 },
15222 		{ "Front Mic", 0x1 },
15223 		{ "Line", 0x2 },
15224 		{ "CD", 0x4 },
15225 	},
15226 };
15227 
15228 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15229 	.num_items = 2,
15230 	.items = {
15231 		{ "Mic", 0x1 },
15232 		{ "Line", 0x2 },
15233 	},
15234 };
15235 
15236 static struct hda_input_mux alc662_eeepc_capture_source = {
15237 	.num_items = 2,
15238 	.items = {
15239 		{ "i-Mic", 0x1 },
15240 		{ "e-Mic", 0x0 },
15241 	},
15242 };
15243 
15244 static struct hda_input_mux alc663_capture_source = {
15245 	.num_items = 3,
15246 	.items = {
15247 		{ "Mic", 0x0 },
15248 		{ "Front Mic", 0x1 },
15249 		{ "Line", 0x2 },
15250 	},
15251 };
15252 
15253 static struct hda_input_mux alc663_m51va_capture_source = {
15254 	.num_items = 2,
15255 	.items = {
15256 		{ "Ext-Mic", 0x0 },
15257 		{ "D-Mic", 0x9 },
15258 	},
15259 };
15260 
15261 /*
15262  * 2ch mode
15263  */
15264 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15265 	{ 2, NULL }
15266 };
15267 
15268 /*
15269  * 2ch mode
15270  */
15271 static struct hda_verb alc662_3ST_ch2_init[] = {
15272 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15273 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15274 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15275 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15276 	{ } /* end */
15277 };
15278 
15279 /*
15280  * 6ch mode
15281  */
15282 static struct hda_verb alc662_3ST_ch6_init[] = {
15283 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15284 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15285 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15286 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15287 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15288 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15289 	{ } /* end */
15290 };
15291 
15292 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15293 	{ 2, alc662_3ST_ch2_init },
15294 	{ 6, alc662_3ST_ch6_init },
15295 };
15296 
15297 /*
15298  * 2ch mode
15299  */
15300 static struct hda_verb alc662_sixstack_ch6_init[] = {
15301 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15302 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15303 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15304 	{ } /* end */
15305 };
15306 
15307 /*
15308  * 6ch mode
15309  */
15310 static struct hda_verb alc662_sixstack_ch8_init[] = {
15311 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15312 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15313 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15314 	{ } /* end */
15315 };
15316 
15317 static struct hda_channel_mode alc662_5stack_modes[2] = {
15318 	{ 2, alc662_sixstack_ch6_init },
15319 	{ 6, alc662_sixstack_ch8_init },
15320 };
15321 
15322 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15323  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15324  */
15325 
15326 static struct snd_kcontrol_new alc662_base_mixer[] = {
15327 	/* output mixer control */
15328 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15329 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15330 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15331 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15332 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15333 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15334 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15335 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15336 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15337 
15338 	/*Input mixer control */
15339 	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15340 	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15341 	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15342 	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15343 	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15344 	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15345 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15346 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15347 	{ } /* end */
15348 };
15349 
15350 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15351 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15352 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15353 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15354 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15355 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15356 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15357 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15358 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15359 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15360 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15361 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15362 	{ } /* end */
15363 };
15364 
15365 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15366 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15367 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15368 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15369 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15370 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15371 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15372 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15373 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15374 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15375 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15376 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15377 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15378 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15379 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15380 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15381 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15382 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15383 	{ } /* end */
15384 };
15385 
15386 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15387 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15388 	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15389 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15390 	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15391 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15392 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15393 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15394 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15395 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15396 	{ } /* end */
15397 };
15398 
15399 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15400 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15401 
15402 	HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15403 	HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15404 
15405 	HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15406 	HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15407 	HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15408 
15409 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15410 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15411 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15412 	{ } /* end */
15413 };
15414 
15415 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15416 	HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15417 	HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15418 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15419 	HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15420 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15421 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15422 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15423 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15424 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15425 	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15426 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15427 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15428 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15429 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15430 	{ } /* end */
15431 };
15432 
15433 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15434 	.ops = &snd_hda_bind_vol,
15435 	.values = {
15436 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15437 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15438 		0
15439 	},
15440 };
15441 
15442 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15443 	.ops = &snd_hda_bind_sw,
15444 	.values = {
15445 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15446 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15447 		0
15448 	},
15449 };
15450 
15451 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15452 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15453 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15454 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15455 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15456 	{ } /* end */
15457 };
15458 
15459 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15460 	.ops = &snd_hda_bind_sw,
15461 	.values = {
15462 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15463 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15464 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15465 		0
15466 	},
15467 };
15468 
15469 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15470 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15471 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15472 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15473 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15474 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15475 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15476 
15477 	{ } /* end */
15478 };
15479 
15480 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15481 	.ops = &snd_hda_bind_sw,
15482 	.values = {
15483 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15484 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15485 		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15486 		0
15487 	},
15488 };
15489 
15490 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15491 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15492 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15493 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15494 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15495 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15496 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15497 	{ } /* end */
15498 };
15499 
15500 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15501 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15502 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15503 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15504 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15505 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15506 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15507 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15508 	{ } /* end */
15509 };
15510 
15511 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15512 	.ops = &snd_hda_bind_vol,
15513 	.values = {
15514 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15515 		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15516 		0
15517 	},
15518 };
15519 
15520 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15521 	.ops = &snd_hda_bind_sw,
15522 	.values = {
15523 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15524 		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15525 		0
15526 	},
15527 };
15528 
15529 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15530 	HDA_BIND_VOL("Master Playback Volume",
15531 				&alc663_asus_two_bind_master_vol),
15532 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15533 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15534 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15535 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15536 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15537 	{ } /* end */
15538 };
15539 
15540 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15541 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15542 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15543 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15544 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15545 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15546 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15547 	{ } /* end */
15548 };
15549 
15550 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15551 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15552 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15553 	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15554 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15555 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15556 
15557 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15558 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15559 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15560 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15561 	{ } /* end */
15562 };
15563 
15564 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15565 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15566 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15567 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15568 
15569 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15570 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15571 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15572 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15573 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15574 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15575 	{ } /* end */
15576 };
15577 
15578 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15579 	{
15580 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15581 		.name = "Channel Mode",
15582 		.info = alc_ch_mode_info,
15583 		.get = alc_ch_mode_get,
15584 		.put = alc_ch_mode_put,
15585 	},
15586 	{ } /* end */
15587 };
15588 
15589 static struct hda_verb alc662_init_verbs[] = {
15590 	/* ADC: mute amp left and right */
15591 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15592 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15593 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
15594 
15595 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15596 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15597 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15598 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15599 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15600 
15601 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15602 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15603 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15604 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15605 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15606 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15607 
15608 	/* Front Pin: output 0 (0x0c) */
15609 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15610 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15611 
15612 	/* Rear Pin: output 1 (0x0d) */
15613 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15614 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15615 
15616 	/* CLFE Pin: output 2 (0x0e) */
15617 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15618 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15619 
15620 	/* Mic (rear) pin: input vref at 80% */
15621 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15622 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15623 	/* Front Mic pin: input vref at 80% */
15624 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15625 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15626 	/* Line In pin: input */
15627 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15628 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15629 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
15630 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15631 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15632 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15633 	/* CD pin widget for input */
15634 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15635 
15636 	/* FIXME: use matrix-type input source selection */
15637 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15638 	/* Input mixer */
15639 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15640 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15641 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15642 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15643 
15644 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15645 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15646 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15647 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15648 
15649 	/* always trun on EAPD */
15650 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15651 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15652 
15653 	{ }
15654 };
15655 
15656 static struct hda_verb alc662_sue_init_verbs[] = {
15657 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15658 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15659 	{}
15660 };
15661 
15662 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15663 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15664 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15665 	{}
15666 };
15667 
15668 /* Set Unsolicited Event*/
15669 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15670 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15671 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15672 	{}
15673 };
15674 
15675 /*
15676  * generic initialization of ADC, input mixers and output mixers
15677  */
15678 static struct hda_verb alc662_auto_init_verbs[] = {
15679 	/*
15680 	 * Unmute ADC and set the default input to mic-in
15681 	 */
15682 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15683 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15684 
15685 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15686 	 * mixer widget
15687 	 * Note: PASD motherboards uses the Line In 2 as the input for front
15688 	 * panel mic (mic 2)
15689 	 */
15690 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15691 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15692 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15693 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15694 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15695 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15696 
15697 	/*
15698 	 * Set up output mixers (0x0c - 0x0f)
15699 	 */
15700 	/* set vol=0 to output mixers */
15701 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15702 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15703 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15704 
15705 	/* set up input amps for analog loopback */
15706 	/* Amp Indices: DAC = 0, mixer = 1 */
15707 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15708 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15709 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15710 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15711 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15712 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15713 
15714 
15715 	/* FIXME: use matrix-type input source selection */
15716 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15717 	/* Input mixer */
15718 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15719 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15720 	{ }
15721 };
15722 
15723 /* additional verbs for ALC663 */
15724 static struct hda_verb alc663_auto_init_verbs[] = {
15725 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15726 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15727 	{ }
15728 };
15729 
15730 static struct hda_verb alc663_m51va_init_verbs[] = {
15731 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15732 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15733 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15734 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15735 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15736 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15737 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15738 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15739 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15740 	{}
15741 };
15742 
15743 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15744 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15745 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15746 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15747 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15748 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15749 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15750 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15751 	{}
15752 };
15753 
15754 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15755 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15756 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15757 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15758 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
15759 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15760 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15761 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15762 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15763 	{}
15764 };
15765 
15766 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15767 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15768 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15769 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15770 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15771 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15772 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15773 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15774 	{}
15775 };
15776 
15777 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15778 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15779 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15780 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15781 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
15782 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15783 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15784 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
15785 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15786 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15787 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15788 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15789 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15790 	{}
15791 };
15792 
15793 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15794 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15795 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15796 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15797 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15798 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15799 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15800 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15801 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15802 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15803 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15804 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15805 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15806 	{}
15807 };
15808 
15809 static struct hda_verb alc663_g71v_init_verbs[] = {
15810 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15811 	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15812 	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15813 
15814 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15815 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15816 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
15817 
15818 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15819 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15820 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15821 	{}
15822 };
15823 
15824 static struct hda_verb alc663_g50v_init_verbs[] = {
15825 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15826 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15827 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
15828 
15829 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15830 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15831 	{}
15832 };
15833 
15834 static struct hda_verb alc662_ecs_init_verbs[] = {
15835 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15836 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15837 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15838 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15839 	{}
15840 };
15841 
15842 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15843 	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15844 	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15845 	{ } /* end */
15846 };
15847 
15848 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15849 {
15850 	unsigned int present;
15851 	unsigned char bits;
15852 
15853 	present = snd_hda_codec_read(codec, 0x14, 0,
15854 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15855 	bits = present ? HDA_AMP_MUTE : 0;
15856 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15857 				 HDA_AMP_MUTE, bits);
15858 }
15859 
15860 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15861 {
15862 	unsigned int present;
15863 	unsigned char bits;
15864 
15865  	present = snd_hda_codec_read(codec, 0x1b, 0,
15866 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15867 	bits = present ? HDA_AMP_MUTE : 0;
15868 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15869 				 HDA_AMP_MUTE, bits);
15870 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15871 				 HDA_AMP_MUTE, bits);
15872 }
15873 
15874 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15875 					   unsigned int res)
15876 {
15877 	if ((res >> 26) == ALC880_HP_EVENT)
15878 		alc662_lenovo_101e_all_automute(codec);
15879 	if ((res >> 26) == ALC880_FRONT_EVENT)
15880 		alc662_lenovo_101e_ispeaker_automute(codec);
15881 }
15882 
15883 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15884 {
15885 	unsigned int present;
15886 
15887 	present = snd_hda_codec_read(codec, 0x18, 0,
15888 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15889 	snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15890 			    0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15891 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15892 			    0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15893 	snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15894 			    0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15895 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15896 			    0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15897 }
15898 
15899 /* unsolicited event for HP jack sensing */
15900 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15901 				     unsigned int res)
15902 {
15903 	if ((res >> 26) == ALC880_HP_EVENT)
15904 		alc262_hippo1_automute( codec );
15905 
15906 	if ((res >> 26) == ALC880_MIC_EVENT)
15907 		alc662_eeepc_mic_automute(codec);
15908 }
15909 
15910 static void alc662_eeepc_inithook(struct hda_codec *codec)
15911 {
15912 	alc262_hippo1_automute( codec );
15913 	alc662_eeepc_mic_automute(codec);
15914 }
15915 
15916 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15917 {
15918 	unsigned int mute;
15919 	unsigned int present;
15920 
15921 	snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15922 	present = snd_hda_codec_read(codec, 0x14, 0,
15923 				     AC_VERB_GET_PIN_SENSE, 0);
15924 	present = (present & 0x80000000) != 0;
15925 	if (present) {
15926 		/* mute internal speaker */
15927 		snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15928 					HDA_AMP_MUTE, HDA_AMP_MUTE);
15929 	} else {
15930 		/* unmute internal speaker if necessary */
15931 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15932 		snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15933 					HDA_AMP_MUTE, mute);
15934 	}
15935 }
15936 
15937 /* unsolicited event for HP jack sensing */
15938 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15939 					  unsigned int res)
15940 {
15941 	if ((res >> 26) == ALC880_HP_EVENT)
15942 		alc662_eeepc_ep20_automute(codec);
15943 }
15944 
15945 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15946 {
15947 	alc662_eeepc_ep20_automute(codec);
15948 }
15949 
15950 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15951 {
15952 	unsigned int present;
15953 	unsigned char bits;
15954 
15955 	present = snd_hda_codec_read(codec, 0x21, 0,
15956 			AC_VERB_GET_PIN_SENSE, 0)
15957 			& AC_PINSENSE_PRESENCE;
15958 	bits = present ? HDA_AMP_MUTE : 0;
15959 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15960 				AMP_IN_MUTE(0), bits);
15961 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15962 				AMP_IN_MUTE(0), bits);
15963 }
15964 
15965 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15966 {
15967 	unsigned int present;
15968 	unsigned char bits;
15969 
15970 	present = snd_hda_codec_read(codec, 0x21, 0,
15971 			AC_VERB_GET_PIN_SENSE, 0)
15972 			& AC_PINSENSE_PRESENCE;
15973 	bits = present ? HDA_AMP_MUTE : 0;
15974 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15975 				AMP_IN_MUTE(0), bits);
15976 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15977 				AMP_IN_MUTE(0), bits);
15978 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15979 				AMP_IN_MUTE(0), bits);
15980 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15981 				AMP_IN_MUTE(0), bits);
15982 }
15983 
15984 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15985 {
15986 	unsigned int present;
15987 	unsigned char bits;
15988 
15989 	present = snd_hda_codec_read(codec, 0x15, 0,
15990 			AC_VERB_GET_PIN_SENSE, 0)
15991 			& AC_PINSENSE_PRESENCE;
15992 	bits = present ? HDA_AMP_MUTE : 0;
15993 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15994 				AMP_IN_MUTE(0), bits);
15995 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15996 				AMP_IN_MUTE(0), bits);
15997 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15998 				AMP_IN_MUTE(0), bits);
15999 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16000 				AMP_IN_MUTE(0), bits);
16001 }
16002 
16003 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16004 {
16005 	unsigned int present;
16006 	unsigned char bits;
16007 
16008 	present = snd_hda_codec_read(codec, 0x1b, 0,
16009 			AC_VERB_GET_PIN_SENSE, 0)
16010 			& AC_PINSENSE_PRESENCE;
16011 	bits = present ? 0 : PIN_OUT;
16012 	snd_hda_codec_write(codec, 0x14, 0,
16013 			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16014 }
16015 
16016 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16017 {
16018 	unsigned int present1, present2;
16019 
16020 	present1 = snd_hda_codec_read(codec, 0x21, 0,
16021 			AC_VERB_GET_PIN_SENSE, 0)
16022 			& AC_PINSENSE_PRESENCE;
16023 	present2 = snd_hda_codec_read(codec, 0x15, 0,
16024 			AC_VERB_GET_PIN_SENSE, 0)
16025 			& AC_PINSENSE_PRESENCE;
16026 
16027 	if (present1 || present2) {
16028 		snd_hda_codec_write_cache(codec, 0x14, 0,
16029 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16030 	} else {
16031 		snd_hda_codec_write_cache(codec, 0x14, 0,
16032 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16033 	}
16034 }
16035 
16036 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16037 {
16038 	unsigned int present1, present2;
16039 
16040 	present1 = snd_hda_codec_read(codec, 0x1b, 0,
16041 				AC_VERB_GET_PIN_SENSE, 0)
16042 				& AC_PINSENSE_PRESENCE;
16043 	present2 = snd_hda_codec_read(codec, 0x15, 0,
16044 				AC_VERB_GET_PIN_SENSE, 0)
16045 				& AC_PINSENSE_PRESENCE;
16046 
16047 	if (present1 || present2) {
16048 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16049 				AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16050 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16051 				AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16052 	} else {
16053 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16054 				AMP_IN_MUTE(0), 0);
16055 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16056 				AMP_IN_MUTE(0), 0);
16057 	}
16058 }
16059 
16060 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16061 {
16062 	unsigned int present;
16063 
16064 	present = snd_hda_codec_read(codec, 0x18, 0,
16065 			AC_VERB_GET_PIN_SENSE, 0)
16066 			& AC_PINSENSE_PRESENCE;
16067 	snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16068 			0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16069 	snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16070 			0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16071 	snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16072 			0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16073 	snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16074 			0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16075 }
16076 
16077 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16078 					   unsigned int res)
16079 {
16080 	switch (res >> 26) {
16081 	case ALC880_HP_EVENT:
16082 		alc663_m51va_speaker_automute(codec);
16083 		break;
16084 	case ALC880_MIC_EVENT:
16085 		alc663_m51va_mic_automute(codec);
16086 		break;
16087 	}
16088 }
16089 
16090 static void alc663_m51va_inithook(struct hda_codec *codec)
16091 {
16092 	alc663_m51va_speaker_automute(codec);
16093 	alc663_m51va_mic_automute(codec);
16094 }
16095 
16096 /* ***************** Mode1 ******************************/
16097 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16098 					   unsigned int res)
16099 {
16100 	switch (res >> 26) {
16101 	case ALC880_HP_EVENT:
16102 		alc663_m51va_speaker_automute(codec);
16103 		break;
16104 	case ALC880_MIC_EVENT:
16105 		alc662_eeepc_mic_automute(codec);
16106 		break;
16107 	}
16108 }
16109 
16110 static void alc663_mode1_inithook(struct hda_codec *codec)
16111 {
16112 	alc663_m51va_speaker_automute(codec);
16113 	alc662_eeepc_mic_automute(codec);
16114 }
16115 /* ***************** Mode2 ******************************/
16116 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16117 					   unsigned int res)
16118 {
16119 	switch (res >> 26) {
16120 	case ALC880_HP_EVENT:
16121 		alc662_f5z_speaker_automute(codec);
16122 		break;
16123 	case ALC880_MIC_EVENT:
16124 		alc662_eeepc_mic_automute(codec);
16125 		break;
16126 	}
16127 }
16128 
16129 static void alc662_mode2_inithook(struct hda_codec *codec)
16130 {
16131 	alc662_f5z_speaker_automute(codec);
16132 	alc662_eeepc_mic_automute(codec);
16133 }
16134 /* ***************** Mode3 ******************************/
16135 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16136 					   unsigned int res)
16137 {
16138 	switch (res >> 26) {
16139 	case ALC880_HP_EVENT:
16140 		alc663_two_hp_m1_speaker_automute(codec);
16141 		break;
16142 	case ALC880_MIC_EVENT:
16143 		alc662_eeepc_mic_automute(codec);
16144 		break;
16145 	}
16146 }
16147 
16148 static void alc663_mode3_inithook(struct hda_codec *codec)
16149 {
16150 	alc663_two_hp_m1_speaker_automute(codec);
16151 	alc662_eeepc_mic_automute(codec);
16152 }
16153 /* ***************** Mode4 ******************************/
16154 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16155 					   unsigned int res)
16156 {
16157 	switch (res >> 26) {
16158 	case ALC880_HP_EVENT:
16159 		alc663_21jd_two_speaker_automute(codec);
16160 		break;
16161 	case ALC880_MIC_EVENT:
16162 		alc662_eeepc_mic_automute(codec);
16163 		break;
16164 	}
16165 }
16166 
16167 static void alc663_mode4_inithook(struct hda_codec *codec)
16168 {
16169 	alc663_21jd_two_speaker_automute(codec);
16170 	alc662_eeepc_mic_automute(codec);
16171 }
16172 /* ***************** Mode5 ******************************/
16173 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16174 					   unsigned int res)
16175 {
16176 	switch (res >> 26) {
16177 	case ALC880_HP_EVENT:
16178 		alc663_15jd_two_speaker_automute(codec);
16179 		break;
16180 	case ALC880_MIC_EVENT:
16181 		alc662_eeepc_mic_automute(codec);
16182 		break;
16183 	}
16184 }
16185 
16186 static void alc663_mode5_inithook(struct hda_codec *codec)
16187 {
16188 	alc663_15jd_two_speaker_automute(codec);
16189 	alc662_eeepc_mic_automute(codec);
16190 }
16191 /* ***************** Mode6 ******************************/
16192 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16193 					   unsigned int res)
16194 {
16195 	switch (res >> 26) {
16196 	case ALC880_HP_EVENT:
16197 		alc663_two_hp_m2_speaker_automute(codec);
16198 		break;
16199 	case ALC880_MIC_EVENT:
16200 		alc662_eeepc_mic_automute(codec);
16201 		break;
16202 	}
16203 }
16204 
16205 static void alc663_mode6_inithook(struct hda_codec *codec)
16206 {
16207 	alc663_two_hp_m2_speaker_automute(codec);
16208 	alc662_eeepc_mic_automute(codec);
16209 }
16210 
16211 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16212 {
16213 	unsigned int present;
16214 	unsigned char bits;
16215 
16216 	present = snd_hda_codec_read(codec, 0x21, 0,
16217 				     AC_VERB_GET_PIN_SENSE, 0)
16218 		& AC_PINSENSE_PRESENCE;
16219 	bits = present ? HDA_AMP_MUTE : 0;
16220 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16221 				 HDA_AMP_MUTE, bits);
16222 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16223 				 HDA_AMP_MUTE, bits);
16224 }
16225 
16226 static void alc663_g71v_front_automute(struct hda_codec *codec)
16227 {
16228 	unsigned int present;
16229 	unsigned char bits;
16230 
16231 	present = snd_hda_codec_read(codec, 0x15, 0,
16232 				     AC_VERB_GET_PIN_SENSE, 0)
16233 		& AC_PINSENSE_PRESENCE;
16234 	bits = present ? HDA_AMP_MUTE : 0;
16235 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16236 				 HDA_AMP_MUTE, bits);
16237 }
16238 
16239 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16240 					   unsigned int res)
16241 {
16242 	switch (res >> 26) {
16243 	case ALC880_HP_EVENT:
16244 		alc663_g71v_hp_automute(codec);
16245 		break;
16246 	case ALC880_FRONT_EVENT:
16247 		alc663_g71v_front_automute(codec);
16248 		break;
16249 	case ALC880_MIC_EVENT:
16250 		alc662_eeepc_mic_automute(codec);
16251 		break;
16252 	}
16253 }
16254 
16255 static void alc663_g71v_inithook(struct hda_codec *codec)
16256 {
16257 	alc663_g71v_front_automute(codec);
16258 	alc663_g71v_hp_automute(codec);
16259 	alc662_eeepc_mic_automute(codec);
16260 }
16261 
16262 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16263 					   unsigned int res)
16264 {
16265 	switch (res >> 26) {
16266 	case ALC880_HP_EVENT:
16267 		alc663_m51va_speaker_automute(codec);
16268 		break;
16269 	case ALC880_MIC_EVENT:
16270 		alc662_eeepc_mic_automute(codec);
16271 		break;
16272 	}
16273 }
16274 
16275 static void alc663_g50v_inithook(struct hda_codec *codec)
16276 {
16277 	alc663_m51va_speaker_automute(codec);
16278 	alc662_eeepc_mic_automute(codec);
16279 }
16280 
16281 /* bind hp and internal speaker mute (with plug check) */
16282 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16283 				     struct snd_ctl_elem_value *ucontrol)
16284 {
16285 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16286 	long *valp = ucontrol->value.integer.value;
16287 	int change;
16288 
16289 	change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16290 					  HDA_AMP_MUTE,
16291 					  valp[0] ? 0 : HDA_AMP_MUTE);
16292 	change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16293 					   HDA_AMP_MUTE,
16294 					   valp[1] ? 0 : HDA_AMP_MUTE);
16295 	if (change)
16296 		alc262_hippo1_automute(codec);
16297 	return change;
16298 }
16299 
16300 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16301 	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16302 	{
16303 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16304 		.name = "Master Playback Switch",
16305 		.info = snd_hda_mixer_amp_switch_info,
16306 		.get = snd_hda_mixer_amp_switch_get,
16307 		.put = alc662_ecs_master_sw_put,
16308 		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16309 	},
16310 
16311 	HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16312 	HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16313 	HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16314 
16315 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16316 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16317 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16318 	{ } /* end */
16319 };
16320 
16321 #ifdef CONFIG_SND_HDA_POWER_SAVE
16322 #define alc662_loopbacks	alc880_loopbacks
16323 #endif
16324 
16325 
16326 /* pcm configuration: identiacal with ALC880 */
16327 #define alc662_pcm_analog_playback	alc880_pcm_analog_playback
16328 #define alc662_pcm_analog_capture	alc880_pcm_analog_capture
16329 #define alc662_pcm_digital_playback	alc880_pcm_digital_playback
16330 #define alc662_pcm_digital_capture	alc880_pcm_digital_capture
16331 
16332 /*
16333  * configuration and preset
16334  */
16335 static const char *alc662_models[ALC662_MODEL_LAST] = {
16336 	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
16337 	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
16338 	[ALC662_3ST_6ch]	= "3stack-6ch",
16339 	[ALC662_5ST_DIG]	= "6stack-dig",
16340 	[ALC662_LENOVO_101E]	= "lenovo-101e",
16341 	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16342 	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16343 	[ALC662_ECS] = "ecs",
16344 	[ALC663_ASUS_M51VA] = "m51va",
16345 	[ALC663_ASUS_G71V] = "g71v",
16346 	[ALC663_ASUS_H13] = "h13",
16347 	[ALC663_ASUS_G50V] = "g50v",
16348 	[ALC663_ASUS_MODE1] = "asus-mode1",
16349 	[ALC662_ASUS_MODE2] = "asus-mode2",
16350 	[ALC663_ASUS_MODE3] = "asus-mode3",
16351 	[ALC663_ASUS_MODE4] = "asus-mode4",
16352 	[ALC663_ASUS_MODE5] = "asus-mode5",
16353 	[ALC663_ASUS_MODE6] = "asus-mode6",
16354 	[ALC662_AUTO]		= "auto",
16355 };
16356 
16357 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16358 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16359 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16360 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16361 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16362 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16363 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16364 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16365 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16366 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16367 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16368 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16369 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16370 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16371 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16372 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16373 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16374 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16375 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16376 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16377 	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16378 	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16379 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16380 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16381 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16382 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16383 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16384 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16385 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16386 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16387 	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16388 	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16389 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16390 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16391 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16392 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16393 	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16394 	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16395 	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16396 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16397 	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16398 		      ALC662_3ST_6ch_DIG),
16399 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16400 		      ALC662_3ST_6ch_DIG),
16401 	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16402 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16403 	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16404 					ALC662_3ST_6ch_DIG),
16405 	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16406 			   ALC663_ASUS_H13),
16407 	{}
16408 };
16409 
16410 static struct alc_config_preset alc662_presets[] = {
16411 	[ALC662_3ST_2ch_DIG] = {
16412 		.mixers = { alc662_3ST_2ch_mixer },
16413 		.init_verbs = { alc662_init_verbs },
16414 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16415 		.dac_nids = alc662_dac_nids,
16416 		.dig_out_nid = ALC662_DIGOUT_NID,
16417 		.dig_in_nid = ALC662_DIGIN_NID,
16418 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16419 		.channel_mode = alc662_3ST_2ch_modes,
16420 		.input_mux = &alc662_capture_source,
16421 	},
16422 	[ALC662_3ST_6ch_DIG] = {
16423 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16424 		.init_verbs = { alc662_init_verbs },
16425 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16426 		.dac_nids = alc662_dac_nids,
16427 		.dig_out_nid = ALC662_DIGOUT_NID,
16428 		.dig_in_nid = ALC662_DIGIN_NID,
16429 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16430 		.channel_mode = alc662_3ST_6ch_modes,
16431 		.need_dac_fix = 1,
16432 		.input_mux = &alc662_capture_source,
16433 	},
16434 	[ALC662_3ST_6ch] = {
16435 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16436 		.init_verbs = { alc662_init_verbs },
16437 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16438 		.dac_nids = alc662_dac_nids,
16439 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16440 		.channel_mode = alc662_3ST_6ch_modes,
16441 		.need_dac_fix = 1,
16442 		.input_mux = &alc662_capture_source,
16443 	},
16444 	[ALC662_5ST_DIG] = {
16445 		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
16446 		.init_verbs = { alc662_init_verbs },
16447 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16448 		.dac_nids = alc662_dac_nids,
16449 		.dig_out_nid = ALC662_DIGOUT_NID,
16450 		.dig_in_nid = ALC662_DIGIN_NID,
16451 		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16452 		.channel_mode = alc662_5stack_modes,
16453 		.input_mux = &alc662_capture_source,
16454 	},
16455 	[ALC662_LENOVO_101E] = {
16456 		.mixers = { alc662_lenovo_101e_mixer },
16457 		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16458 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16459 		.dac_nids = alc662_dac_nids,
16460 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16461 		.channel_mode = alc662_3ST_2ch_modes,
16462 		.input_mux = &alc662_lenovo_101e_capture_source,
16463 		.unsol_event = alc662_lenovo_101e_unsol_event,
16464 		.init_hook = alc662_lenovo_101e_all_automute,
16465 	},
16466 	[ALC662_ASUS_EEEPC_P701] = {
16467 		.mixers = { alc662_eeepc_p701_mixer },
16468 		.init_verbs = { alc662_init_verbs,
16469 				alc662_eeepc_sue_init_verbs },
16470 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16471 		.dac_nids = alc662_dac_nids,
16472 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16473 		.channel_mode = alc662_3ST_2ch_modes,
16474 		.input_mux = &alc662_eeepc_capture_source,
16475 		.unsol_event = alc662_eeepc_unsol_event,
16476 		.init_hook = alc662_eeepc_inithook,
16477 	},
16478 	[ALC662_ASUS_EEEPC_EP20] = {
16479 		.mixers = { alc662_eeepc_ep20_mixer,
16480 			    alc662_chmode_mixer },
16481 		.init_verbs = { alc662_init_verbs,
16482 				alc662_eeepc_ep20_sue_init_verbs },
16483 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16484 		.dac_nids = alc662_dac_nids,
16485 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16486 		.channel_mode = alc662_3ST_6ch_modes,
16487 		.input_mux = &alc662_lenovo_101e_capture_source,
16488 		.unsol_event = alc662_eeepc_ep20_unsol_event,
16489 		.init_hook = alc662_eeepc_ep20_inithook,
16490 	},
16491 	[ALC662_ECS] = {
16492 		.mixers = { alc662_ecs_mixer },
16493 		.init_verbs = { alc662_init_verbs,
16494 				alc662_ecs_init_verbs },
16495 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16496 		.dac_nids = alc662_dac_nids,
16497 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16498 		.channel_mode = alc662_3ST_2ch_modes,
16499 		.input_mux = &alc662_eeepc_capture_source,
16500 		.unsol_event = alc662_eeepc_unsol_event,
16501 		.init_hook = alc662_eeepc_inithook,
16502 	},
16503 	[ALC663_ASUS_M51VA] = {
16504 		.mixers = { alc663_m51va_mixer },
16505 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16506 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16507 		.dac_nids = alc662_dac_nids,
16508 		.dig_out_nid = ALC662_DIGOUT_NID,
16509 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16510 		.channel_mode = alc662_3ST_2ch_modes,
16511 		.input_mux = &alc663_m51va_capture_source,
16512 		.unsol_event = alc663_m51va_unsol_event,
16513 		.init_hook = alc663_m51va_inithook,
16514 	},
16515 	[ALC663_ASUS_G71V] = {
16516 		.mixers = { alc663_g71v_mixer },
16517 		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16518 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16519 		.dac_nids = alc662_dac_nids,
16520 		.dig_out_nid = ALC662_DIGOUT_NID,
16521 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16522 		.channel_mode = alc662_3ST_2ch_modes,
16523 		.input_mux = &alc662_eeepc_capture_source,
16524 		.unsol_event = alc663_g71v_unsol_event,
16525 		.init_hook = alc663_g71v_inithook,
16526 	},
16527 	[ALC663_ASUS_H13] = {
16528 		.mixers = { alc663_m51va_mixer },
16529 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16530 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16531 		.dac_nids = alc662_dac_nids,
16532 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16533 		.channel_mode = alc662_3ST_2ch_modes,
16534 		.input_mux = &alc663_m51va_capture_source,
16535 		.unsol_event = alc663_m51va_unsol_event,
16536 		.init_hook = alc663_m51va_inithook,
16537 	},
16538 	[ALC663_ASUS_G50V] = {
16539 		.mixers = { alc663_g50v_mixer },
16540 		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16541 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16542 		.dac_nids = alc662_dac_nids,
16543 		.dig_out_nid = ALC662_DIGOUT_NID,
16544 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16545 		.channel_mode = alc662_3ST_6ch_modes,
16546 		.input_mux = &alc663_capture_source,
16547 		.unsol_event = alc663_g50v_unsol_event,
16548 		.init_hook = alc663_g50v_inithook,
16549 	},
16550 	[ALC663_ASUS_MODE1] = {
16551 		.mixers = { alc663_m51va_mixer },
16552 		.cap_mixer = alc662_auto_capture_mixer,
16553 		.init_verbs = { alc662_init_verbs,
16554 				alc663_21jd_amic_init_verbs },
16555 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16556 		.hp_nid = 0x03,
16557 		.dac_nids = alc662_dac_nids,
16558 		.dig_out_nid = ALC662_DIGOUT_NID,
16559 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16560 		.channel_mode = alc662_3ST_2ch_modes,
16561 		.input_mux = &alc662_eeepc_capture_source,
16562 		.unsol_event = alc663_mode1_unsol_event,
16563 		.init_hook = alc663_mode1_inithook,
16564 	},
16565 	[ALC662_ASUS_MODE2] = {
16566 		.mixers = { alc662_1bjd_mixer },
16567 		.cap_mixer = alc662_auto_capture_mixer,
16568 		.init_verbs = { alc662_init_verbs,
16569 				alc662_1bjd_amic_init_verbs },
16570 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16571 		.dac_nids = alc662_dac_nids,
16572 		.dig_out_nid = ALC662_DIGOUT_NID,
16573 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16574 		.channel_mode = alc662_3ST_2ch_modes,
16575 		.input_mux = &alc662_eeepc_capture_source,
16576 		.unsol_event = alc662_mode2_unsol_event,
16577 		.init_hook = alc662_mode2_inithook,
16578 	},
16579 	[ALC663_ASUS_MODE3] = {
16580 		.mixers = { alc663_two_hp_m1_mixer },
16581 		.cap_mixer = alc662_auto_capture_mixer,
16582 		.init_verbs = { alc662_init_verbs,
16583 				alc663_two_hp_amic_m1_init_verbs },
16584 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16585 		.hp_nid = 0x03,
16586 		.dac_nids = alc662_dac_nids,
16587 		.dig_out_nid = ALC662_DIGOUT_NID,
16588 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16589 		.channel_mode = alc662_3ST_2ch_modes,
16590 		.input_mux = &alc662_eeepc_capture_source,
16591 		.unsol_event = alc663_mode3_unsol_event,
16592 		.init_hook = alc663_mode3_inithook,
16593 	},
16594 	[ALC663_ASUS_MODE4] = {
16595 		.mixers = { alc663_asus_21jd_clfe_mixer },
16596 		.cap_mixer = alc662_auto_capture_mixer,
16597 		.init_verbs = { alc662_init_verbs,
16598 				alc663_21jd_amic_init_verbs},
16599 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16600 		.hp_nid = 0x03,
16601 		.dac_nids = alc662_dac_nids,
16602 		.dig_out_nid = ALC662_DIGOUT_NID,
16603 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16604 		.channel_mode = alc662_3ST_2ch_modes,
16605 		.input_mux = &alc662_eeepc_capture_source,
16606 		.unsol_event = alc663_mode4_unsol_event,
16607 		.init_hook = alc663_mode4_inithook,
16608 	},
16609 	[ALC663_ASUS_MODE5] = {
16610 		.mixers = { alc663_asus_15jd_clfe_mixer },
16611 		.cap_mixer = alc662_auto_capture_mixer,
16612 		.init_verbs = { alc662_init_verbs,
16613 				alc663_15jd_amic_init_verbs },
16614 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16615 		.hp_nid = 0x03,
16616 		.dac_nids = alc662_dac_nids,
16617 		.dig_out_nid = ALC662_DIGOUT_NID,
16618 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16619 		.channel_mode = alc662_3ST_2ch_modes,
16620 		.input_mux = &alc662_eeepc_capture_source,
16621 		.unsol_event = alc663_mode5_unsol_event,
16622 		.init_hook = alc663_mode5_inithook,
16623 	},
16624 	[ALC663_ASUS_MODE6] = {
16625 		.mixers = { alc663_two_hp_m2_mixer },
16626 		.cap_mixer = alc662_auto_capture_mixer,
16627 		.init_verbs = { alc662_init_verbs,
16628 				alc663_two_hp_amic_m2_init_verbs },
16629 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16630 		.hp_nid = 0x03,
16631 		.dac_nids = alc662_dac_nids,
16632 		.dig_out_nid = ALC662_DIGOUT_NID,
16633 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16634 		.channel_mode = alc662_3ST_2ch_modes,
16635 		.input_mux = &alc662_eeepc_capture_source,
16636 		.unsol_event = alc663_mode6_unsol_event,
16637 		.init_hook = alc663_mode6_inithook,
16638 	},
16639 };
16640 
16641 
16642 /*
16643  * BIOS auto configuration
16644  */
16645 
16646 /* add playback controls from the parsed DAC table */
16647 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16648 					     const struct auto_pin_cfg *cfg)
16649 {
16650 	char name[32];
16651 	static const char *chname[4] = {
16652 		"Front", "Surround", NULL /*CLFE*/, "Side"
16653 	};
16654 	hda_nid_t nid;
16655 	int i, err;
16656 
16657 	for (i = 0; i < cfg->line_outs; i++) {
16658 		if (!spec->multiout.dac_nids[i])
16659 			continue;
16660 		nid = alc880_idx_to_dac(i);
16661 		if (i == 2) {
16662 			/* Center/LFE */
16663 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
16664 					  "Center Playback Volume",
16665 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16666 							      HDA_OUTPUT));
16667 			if (err < 0)
16668 				return err;
16669 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
16670 					  "LFE Playback Volume",
16671 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16672 							      HDA_OUTPUT));
16673 			if (err < 0)
16674 				return err;
16675 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16676 					  "Center Playback Switch",
16677 					  HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16678 							      HDA_INPUT));
16679 			if (err < 0)
16680 				return err;
16681 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16682 					  "LFE Playback Switch",
16683 					  HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16684 							      HDA_INPUT));
16685 			if (err < 0)
16686 				return err;
16687 		} else {
16688 			sprintf(name, "%s Playback Volume", chname[i]);
16689 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16690 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16691 							      HDA_OUTPUT));
16692 			if (err < 0)
16693 				return err;
16694 			sprintf(name, "%s Playback Switch", chname[i]);
16695 			err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16696 				HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16697 						    3, 0, HDA_INPUT));
16698 			if (err < 0)
16699 				return err;
16700 		}
16701 	}
16702 	return 0;
16703 }
16704 
16705 /* add playback controls for speaker and HP outputs */
16706 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16707 					const char *pfx)
16708 {
16709 	hda_nid_t nid;
16710 	int err;
16711 	char name[32];
16712 
16713 	if (!pin)
16714 		return 0;
16715 
16716 	if (pin == 0x17) {
16717 		/* ALC663 has a mono output pin on 0x17 */
16718 		sprintf(name, "%s Playback Switch", pfx);
16719 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16720 				  HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16721 		return err;
16722 	}
16723 
16724 	if (alc880_is_fixed_pin(pin)) {
16725 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16726 		/* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16727 		/* specify the DAC as the extra output */
16728 		if (!spec->multiout.hp_nid)
16729 			spec->multiout.hp_nid = nid;
16730 		else
16731 			spec->multiout.extra_out_nid[0] = nid;
16732 		/* control HP volume/switch on the output mixer amp */
16733 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16734 		sprintf(name, "%s Playback Volume", pfx);
16735 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16736 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16737 		if (err < 0)
16738 			return err;
16739 		sprintf(name, "%s Playback Switch", pfx);
16740 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16741 				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16742 		if (err < 0)
16743 			return err;
16744 	} else if (alc880_is_multi_pin(pin)) {
16745 		/* set manual connection */
16746 		/* we have only a switch on HP-out PIN */
16747 		sprintf(name, "%s Playback Switch", pfx);
16748 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16749 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16750 		if (err < 0)
16751 			return err;
16752 	}
16753 	return 0;
16754 }
16755 
16756 /* return the index of the src widget from the connection list of the nid.
16757  * return -1 if not found
16758  */
16759 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16760 				hda_nid_t src)
16761 {
16762 	hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16763 	int i, conns;
16764 
16765 	conns = snd_hda_get_connections(codec, nid, conn_list,
16766 					ARRAY_SIZE(conn_list));
16767 	if (conns < 0)
16768 		return -1;
16769 	for (i = 0; i < conns; i++)
16770 		if (conn_list[i] == src)
16771 			return i;
16772 	return -1;
16773 }
16774 
16775 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16776 {
16777 	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16778 	return (pincap & AC_PINCAP_IN) != 0;
16779 }
16780 
16781 /* create playback/capture controls for input pins */
16782 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16783 						const struct auto_pin_cfg *cfg)
16784 {
16785 	struct alc_spec *spec = codec->spec;
16786 	struct hda_input_mux *imux = &spec->private_imux[0];
16787 	int i, err, idx;
16788 
16789 	for (i = 0; i < AUTO_PIN_LAST; i++) {
16790 		if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16791 			idx = alc662_input_pin_idx(codec, 0x0b,
16792 						   cfg->input_pins[i]);
16793 			if (idx >= 0) {
16794 				err = new_analog_input(spec, cfg->input_pins[i],
16795 						       auto_pin_cfg_labels[i],
16796 						       idx, 0x0b);
16797 				if (err < 0)
16798 					return err;
16799 			}
16800 			idx = alc662_input_pin_idx(codec, 0x22,
16801 						   cfg->input_pins[i]);
16802 			if (idx >= 0) {
16803 				imux->items[imux->num_items].label =
16804 					auto_pin_cfg_labels[i];
16805 				imux->items[imux->num_items].index = idx;
16806 				imux->num_items++;
16807 			}
16808 		}
16809 	}
16810 	return 0;
16811 }
16812 
16813 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16814 					      hda_nid_t nid, int pin_type,
16815 					      int dac_idx)
16816 {
16817 	alc_set_pin_output(codec, nid, pin_type);
16818 	/* need the manual connection? */
16819 	if (alc880_is_multi_pin(nid)) {
16820 		struct alc_spec *spec = codec->spec;
16821 		int idx = alc880_multi_pin_idx(nid);
16822 		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16823 				    AC_VERB_SET_CONNECT_SEL,
16824 				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16825 	}
16826 }
16827 
16828 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16829 {
16830 	struct alc_spec *spec = codec->spec;
16831 	int i;
16832 
16833 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16834 	for (i = 0; i <= HDA_SIDE; i++) {
16835 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16836 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16837 		if (nid)
16838 			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16839 							  i);
16840 	}
16841 }
16842 
16843 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16844 {
16845 	struct alc_spec *spec = codec->spec;
16846 	hda_nid_t pin;
16847 
16848 	pin = spec->autocfg.hp_pins[0];
16849 	if (pin) /* connect to front */
16850 		/* use dac 0 */
16851 		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16852 	pin = spec->autocfg.speaker_pins[0];
16853 	if (pin)
16854 		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16855 }
16856 
16857 #define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
16858 
16859 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16860 {
16861 	struct alc_spec *spec = codec->spec;
16862 	int i;
16863 
16864 	for (i = 0; i < AUTO_PIN_LAST; i++) {
16865 		hda_nid_t nid = spec->autocfg.input_pins[i];
16866 		if (alc662_is_input_pin(codec, nid)) {
16867 			alc_set_input_pin(codec, nid, i);
16868 			if (nid != ALC662_PIN_CD_NID &&
16869 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16870 				snd_hda_codec_write(codec, nid, 0,
16871 						    AC_VERB_SET_AMP_GAIN_MUTE,
16872 						    AMP_OUT_MUTE);
16873 		}
16874 	}
16875 }
16876 
16877 #define alc662_auto_init_input_src	alc882_auto_init_input_src
16878 
16879 static int alc662_parse_auto_config(struct hda_codec *codec)
16880 {
16881 	struct alc_spec *spec = codec->spec;
16882 	int err;
16883 	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16884 
16885 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16886 					   alc662_ignore);
16887 	if (err < 0)
16888 		return err;
16889 	if (!spec->autocfg.line_outs)
16890 		return 0; /* can't find valid BIOS pin config */
16891 
16892 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16893 	if (err < 0)
16894 		return err;
16895 	err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16896 	if (err < 0)
16897 		return err;
16898 	err = alc662_auto_create_extra_out(spec,
16899 					   spec->autocfg.speaker_pins[0],
16900 					   "Speaker");
16901 	if (err < 0)
16902 		return err;
16903 	err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16904 					   "Headphone");
16905 	if (err < 0)
16906 		return err;
16907 	err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
16908 	if (err < 0)
16909 		return err;
16910 
16911 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16912 
16913 	if (spec->autocfg.dig_outs)
16914 		spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16915 
16916 	if (spec->kctls.list)
16917 		add_mixer(spec, spec->kctls.list);
16918 
16919 	spec->num_mux_defs = 1;
16920 	spec->input_mux = &spec->private_imux[0];
16921 
16922 	add_verb(spec, alc662_auto_init_verbs);
16923 	if (codec->vendor_id == 0x10ec0663)
16924 		add_verb(spec, alc663_auto_init_verbs);
16925 
16926 	err = alc_auto_add_mic_boost(codec);
16927 	if (err < 0)
16928 		return err;
16929 
16930 	return 1;
16931 }
16932 
16933 /* additional initialization for auto-configuration model */
16934 static void alc662_auto_init(struct hda_codec *codec)
16935 {
16936 	struct alc_spec *spec = codec->spec;
16937 	alc662_auto_init_multi_out(codec);
16938 	alc662_auto_init_hp_out(codec);
16939 	alc662_auto_init_analog_input(codec);
16940 	alc662_auto_init_input_src(codec);
16941 	if (spec->unsol_event)
16942 		alc_inithook(codec);
16943 }
16944 
16945 static int patch_alc662(struct hda_codec *codec)
16946 {
16947 	struct alc_spec *spec;
16948 	int err, board_config;
16949 
16950 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16951 	if (!spec)
16952 		return -ENOMEM;
16953 
16954 	codec->spec = spec;
16955 
16956 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
16957 
16958 	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16959 						  alc662_models,
16960 			  	                  alc662_cfg_tbl);
16961 	if (board_config < 0) {
16962 		printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16963 		       "trying auto-probe from BIOS...\n");
16964 		board_config = ALC662_AUTO;
16965 	}
16966 
16967 	if (board_config == ALC662_AUTO) {
16968 		/* automatic parse from the BIOS config */
16969 		err = alc662_parse_auto_config(codec);
16970 		if (err < 0) {
16971 			alc_free(codec);
16972 			return err;
16973 		} else if (!err) {
16974 			printk(KERN_INFO
16975 			       "hda_codec: Cannot set up configuration "
16976 			       "from BIOS.  Using base mode...\n");
16977 			board_config = ALC662_3ST_2ch_DIG;
16978 		}
16979 	}
16980 
16981 	err = snd_hda_attach_beep_device(codec, 0x1);
16982 	if (err < 0) {
16983 		alc_free(codec);
16984 		return err;
16985 	}
16986 
16987 	if (board_config != ALC662_AUTO)
16988 		setup_preset(spec, &alc662_presets[board_config]);
16989 
16990 	if (codec->vendor_id == 0x10ec0663) {
16991 		spec->stream_name_analog = "ALC663 Analog";
16992 		spec->stream_name_digital = "ALC663 Digital";
16993 	} else if (codec->vendor_id == 0x10ec0272) {
16994 		spec->stream_name_analog = "ALC272 Analog";
16995 		spec->stream_name_digital = "ALC272 Digital";
16996 	} else {
16997 		spec->stream_name_analog = "ALC662 Analog";
16998 		spec->stream_name_digital = "ALC662 Digital";
16999 	}
17000 
17001 	spec->stream_analog_playback = &alc662_pcm_analog_playback;
17002 	spec->stream_analog_capture = &alc662_pcm_analog_capture;
17003 
17004 	spec->stream_digital_playback = &alc662_pcm_digital_playback;
17005 	spec->stream_digital_capture = &alc662_pcm_digital_capture;
17006 
17007 	spec->adc_nids = alc662_adc_nids;
17008 	spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17009 	spec->capsrc_nids = alc662_capsrc_nids;
17010 	spec->capture_style = CAPT_MIX;
17011 
17012 	if (!spec->cap_mixer)
17013 		set_capture_mixer(spec);
17014 	if (codec->vendor_id == 0x10ec0662)
17015 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17016 	else
17017 		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17018 
17019 	spec->vmaster_nid = 0x02;
17020 
17021 	codec->patch_ops = alc_patch_ops;
17022 	if (board_config == ALC662_AUTO)
17023 		spec->init_hook = alc662_auto_init;
17024 #ifdef CONFIG_SND_HDA_POWER_SAVE
17025 	if (!spec->loopback.amplist)
17026 		spec->loopback.amplist = alc662_loopbacks;
17027 #endif
17028 	codec->proc_widget_hook = print_realtek_coef;
17029 
17030 	return 0;
17031 }
17032 
17033 /*
17034  * patch entries
17035  */
17036 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17037 	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17038 	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17039 	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17040 	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17041 	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17042 	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17043 	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17044 	  .patch = patch_alc861 },
17045 	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17046 	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17047 	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17048 	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17049 	  .patch = patch_alc883 },
17050 	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17051 	  .patch = patch_alc662 },
17052 	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17053 	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17054 	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17055 	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
17056 	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17057 	  .patch = patch_alc882 }, /* should be patch_alc883() in future */
17058 	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17059 	  .patch = patch_alc882 }, /* should be patch_alc883() in future */
17060 	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17061 	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
17062 	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17063 	  .patch = patch_alc883 },
17064 	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
17065 	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
17066 	{} /* terminator */
17067 };
17068 
17069 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17070 
17071 MODULE_LICENSE("GPL");
17072 MODULE_DESCRIPTION("Realtek HD-audio codec");
17073 
17074 static struct hda_codec_preset_list realtek_list = {
17075 	.preset = snd_hda_preset_realtek,
17076 	.owner = THIS_MODULE,
17077 };
17078 
17079 static int __init patch_realtek_init(void)
17080 {
17081 	return snd_hda_add_codec_preset(&realtek_list);
17082 }
17083 
17084 static void __exit patch_realtek_exit(void)
17085 {
17086 	snd_hda_delete_codec_preset(&realtek_list);
17087 }
17088 
17089 module_init(patch_realtek_init)
17090 module_exit(patch_realtek_exit)
17091