xref: /openbmc/linux/sound/pci/hda/patch_realtek.c (revision b627b4ed) 
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_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8746 		      ALC883_FUJITSU_PI2515),
8747 	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8748 		ALC888_FUJITSU_XA3530),
8749 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8750 	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8751 	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8752 	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8753 	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8754 	SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8755 	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8756 	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8757 	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8758 	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8759 	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8760 	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8761 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8762 	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8763 	{}
8764 };
8765 
8766 static hda_nid_t alc883_slave_dig_outs[] = {
8767 	ALC1200_DIGOUT_NID, 0,
8768 };
8769 
8770 static hda_nid_t alc1200_slave_dig_outs[] = {
8771 	ALC883_DIGOUT_NID, 0,
8772 };
8773 
8774 static struct alc_config_preset alc883_presets[] = {
8775 	[ALC883_3ST_2ch_DIG] = {
8776 		.mixers = { alc883_3ST_2ch_mixer },
8777 		.init_verbs = { alc883_init_verbs },
8778 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8779 		.dac_nids = alc883_dac_nids,
8780 		.dig_out_nid = ALC883_DIGOUT_NID,
8781 		.dig_in_nid = ALC883_DIGIN_NID,
8782 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8783 		.channel_mode = alc883_3ST_2ch_modes,
8784 		.input_mux = &alc883_capture_source,
8785 	},
8786 	[ALC883_3ST_6ch_DIG] = {
8787 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8788 		.init_verbs = { alc883_init_verbs },
8789 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8790 		.dac_nids = alc883_dac_nids,
8791 		.dig_out_nid = ALC883_DIGOUT_NID,
8792 		.dig_in_nid = ALC883_DIGIN_NID,
8793 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8794 		.channel_mode = alc883_3ST_6ch_modes,
8795 		.need_dac_fix = 1,
8796 		.input_mux = &alc883_capture_source,
8797 	},
8798 	[ALC883_3ST_6ch] = {
8799 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8800 		.init_verbs = { alc883_init_verbs },
8801 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8802 		.dac_nids = alc883_dac_nids,
8803 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8804 		.channel_mode = alc883_3ST_6ch_modes,
8805 		.need_dac_fix = 1,
8806 		.input_mux = &alc883_capture_source,
8807 	},
8808 	[ALC883_3ST_6ch_INTEL] = {
8809 		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8810 		.init_verbs = { alc883_init_verbs },
8811 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8812 		.dac_nids = alc883_dac_nids,
8813 		.dig_out_nid = ALC883_DIGOUT_NID,
8814 		.dig_in_nid = ALC883_DIGIN_NID,
8815 		.slave_dig_outs = alc883_slave_dig_outs,
8816 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8817 		.channel_mode = alc883_3ST_6ch_intel_modes,
8818 		.need_dac_fix = 1,
8819 		.input_mux = &alc883_3stack_6ch_intel,
8820 	},
8821 	[ALC883_6ST_DIG] = {
8822 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
8823 		.init_verbs = { alc883_init_verbs },
8824 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8825 		.dac_nids = alc883_dac_nids,
8826 		.dig_out_nid = ALC883_DIGOUT_NID,
8827 		.dig_in_nid = ALC883_DIGIN_NID,
8828 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8829 		.channel_mode = alc883_sixstack_modes,
8830 		.input_mux = &alc883_capture_source,
8831 	},
8832 	[ALC883_TARGA_DIG] = {
8833 		.mixers = { alc883_tagra_mixer, alc883_chmode_mixer },
8834 		.init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8835 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8836 		.dac_nids = alc883_dac_nids,
8837 		.dig_out_nid = ALC883_DIGOUT_NID,
8838 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8839 		.channel_mode = alc883_3ST_6ch_modes,
8840 		.need_dac_fix = 1,
8841 		.input_mux = &alc883_capture_source,
8842 		.unsol_event = alc883_tagra_unsol_event,
8843 		.init_hook = alc883_tagra_automute,
8844 	},
8845 	[ALC883_TARGA_2ch_DIG] = {
8846 		.mixers = { alc883_tagra_2ch_mixer},
8847 		.init_verbs = { alc883_init_verbs, alc883_tagra_verbs},
8848 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8849 		.dac_nids = alc883_dac_nids,
8850 		.adc_nids = alc883_adc_nids_alt,
8851 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8852 		.dig_out_nid = ALC883_DIGOUT_NID,
8853 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8854 		.channel_mode = alc883_3ST_2ch_modes,
8855 		.input_mux = &alc883_capture_source,
8856 		.unsol_event = alc883_tagra_unsol_event,
8857 		.init_hook = alc883_tagra_automute,
8858 	},
8859 	[ALC883_ACER] = {
8860 		.mixers = { alc883_base_mixer },
8861 		/* On TravelMate laptops, GPIO 0 enables the internal speaker
8862 		 * and the headphone jack.  Turn this on and rely on the
8863 		 * standard mute methods whenever the user wants to turn
8864 		 * these outputs off.
8865 		 */
8866 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8867 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8868 		.dac_nids = alc883_dac_nids,
8869 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8870 		.channel_mode = alc883_3ST_2ch_modes,
8871 		.input_mux = &alc883_capture_source,
8872 	},
8873 	[ALC883_ACER_ASPIRE] = {
8874 		.mixers = { alc883_acer_aspire_mixer },
8875 		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8876 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8877 		.dac_nids = alc883_dac_nids,
8878 		.dig_out_nid = ALC883_DIGOUT_NID,
8879 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8880 		.channel_mode = alc883_3ST_2ch_modes,
8881 		.input_mux = &alc883_capture_source,
8882 		.unsol_event = alc883_acer_aspire_unsol_event,
8883 		.init_hook = alc883_acer_aspire_automute,
8884 	},
8885 	[ALC888_ACER_ASPIRE_4930G] = {
8886 		.mixers = { alc888_base_mixer,
8887 				alc883_chmode_mixer },
8888 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8889 				alc888_acer_aspire_4930g_verbs },
8890 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8891 		.dac_nids = alc883_dac_nids,
8892 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8893 		.adc_nids = alc883_adc_nids_rev,
8894 		.capsrc_nids = alc883_capsrc_nids_rev,
8895 		.dig_out_nid = ALC883_DIGOUT_NID,
8896 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8897 		.channel_mode = alc883_3ST_6ch_modes,
8898 		.need_dac_fix = 1,
8899 		.num_mux_defs =
8900 			ARRAY_SIZE(alc888_2_capture_sources),
8901 		.input_mux = alc888_2_capture_sources,
8902 		.unsol_event = alc888_acer_aspire_4930g_unsol_event,
8903 		.init_hook = alc888_acer_aspire_4930g_automute,
8904 	},
8905 	[ALC883_MEDION] = {
8906 		.mixers = { alc883_fivestack_mixer,
8907 			    alc883_chmode_mixer },
8908 		.init_verbs = { alc883_init_verbs,
8909 				alc883_medion_eapd_verbs },
8910 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8911 		.dac_nids = alc883_dac_nids,
8912 		.adc_nids = alc883_adc_nids_alt,
8913 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8914 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8915 		.channel_mode = alc883_sixstack_modes,
8916 		.input_mux = &alc883_capture_source,
8917 	},
8918 	[ALC883_MEDION_MD2] = {
8919 		.mixers = { alc883_medion_md2_mixer},
8920 		.init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8921 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8922 		.dac_nids = alc883_dac_nids,
8923 		.dig_out_nid = ALC883_DIGOUT_NID,
8924 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8925 		.channel_mode = alc883_3ST_2ch_modes,
8926 		.input_mux = &alc883_capture_source,
8927 		.unsol_event = alc883_medion_md2_unsol_event,
8928 		.init_hook = alc883_medion_md2_automute,
8929 	},
8930 	[ALC883_LAPTOP_EAPD] = {
8931 		.mixers = { alc883_base_mixer },
8932 		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8933 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8934 		.dac_nids = alc883_dac_nids,
8935 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8936 		.channel_mode = alc883_3ST_2ch_modes,
8937 		.input_mux = &alc883_capture_source,
8938 	},
8939 	[ALC883_CLEVO_M720] = {
8940 		.mixers = { alc883_clevo_m720_mixer },
8941 		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8942 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8943 		.dac_nids = alc883_dac_nids,
8944 		.dig_out_nid = ALC883_DIGOUT_NID,
8945 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8946 		.channel_mode = alc883_3ST_2ch_modes,
8947 		.input_mux = &alc883_capture_source,
8948 		.unsol_event = alc883_clevo_m720_unsol_event,
8949 		.init_hook = alc883_clevo_m720_automute,
8950 	},
8951 	[ALC883_LENOVO_101E_2ch] = {
8952 		.mixers = { alc883_lenovo_101e_2ch_mixer},
8953 		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8954 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8955 		.dac_nids = alc883_dac_nids,
8956 		.adc_nids = alc883_adc_nids_alt,
8957 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8958 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8959 		.channel_mode = alc883_3ST_2ch_modes,
8960 		.input_mux = &alc883_lenovo_101e_capture_source,
8961 		.unsol_event = alc883_lenovo_101e_unsol_event,
8962 		.init_hook = alc883_lenovo_101e_all_automute,
8963 	},
8964 	[ALC883_LENOVO_NB0763] = {
8965 		.mixers = { alc883_lenovo_nb0763_mixer },
8966 		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8967 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8968 		.dac_nids = alc883_dac_nids,
8969 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8970 		.channel_mode = alc883_3ST_2ch_modes,
8971 		.need_dac_fix = 1,
8972 		.input_mux = &alc883_lenovo_nb0763_capture_source,
8973 		.unsol_event = alc883_medion_md2_unsol_event,
8974 		.init_hook = alc883_medion_md2_automute,
8975 	},
8976 	[ALC888_LENOVO_MS7195_DIG] = {
8977 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8978 		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8979 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8980 		.dac_nids = alc883_dac_nids,
8981 		.dig_out_nid = ALC883_DIGOUT_NID,
8982 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8983 		.channel_mode = alc883_3ST_6ch_modes,
8984 		.need_dac_fix = 1,
8985 		.input_mux = &alc883_capture_source,
8986 		.unsol_event = alc883_lenovo_ms7195_unsol_event,
8987 		.init_hook = alc888_lenovo_ms7195_front_automute,
8988 	},
8989 	[ALC883_HAIER_W66] = {
8990 		.mixers = { alc883_tagra_2ch_mixer},
8991 		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8992 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
8993 		.dac_nids = alc883_dac_nids,
8994 		.dig_out_nid = ALC883_DIGOUT_NID,
8995 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8996 		.channel_mode = alc883_3ST_2ch_modes,
8997 		.input_mux = &alc883_capture_source,
8998 		.unsol_event = alc883_haier_w66_unsol_event,
8999 		.init_hook = alc883_haier_w66_automute,
9000 	},
9001 	[ALC888_3ST_HP] = {
9002 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9003 		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9004 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9005 		.dac_nids = alc883_dac_nids,
9006 		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9007 		.channel_mode = alc888_3st_hp_modes,
9008 		.need_dac_fix = 1,
9009 		.input_mux = &alc883_capture_source,
9010 		.unsol_event = alc888_3st_hp_unsol_event,
9011 		.init_hook = alc888_3st_hp_front_automute,
9012 	},
9013 	[ALC888_6ST_DELL] = {
9014 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9015 		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9016 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9017 		.dac_nids = alc883_dac_nids,
9018 		.dig_out_nid = ALC883_DIGOUT_NID,
9019 		.dig_in_nid = ALC883_DIGIN_NID,
9020 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9021 		.channel_mode = alc883_sixstack_modes,
9022 		.input_mux = &alc883_capture_source,
9023 		.unsol_event = alc888_6st_dell_unsol_event,
9024 		.init_hook = alc888_6st_dell_front_automute,
9025 	},
9026 	[ALC883_MITAC] = {
9027 		.mixers = { alc883_mitac_mixer },
9028 		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9029 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9030 		.dac_nids = alc883_dac_nids,
9031 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9032 		.channel_mode = alc883_3ST_2ch_modes,
9033 		.input_mux = &alc883_capture_source,
9034 		.unsol_event = alc883_mitac_unsol_event,
9035 		.init_hook = alc883_mitac_automute,
9036 	},
9037 	[ALC883_FUJITSU_PI2515] = {
9038 		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9039 		.init_verbs = { alc883_init_verbs,
9040 				alc883_2ch_fujitsu_pi2515_verbs},
9041 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9042 		.dac_nids = alc883_dac_nids,
9043 		.dig_out_nid = ALC883_DIGOUT_NID,
9044 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9045 		.channel_mode = alc883_3ST_2ch_modes,
9046 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9047 		.unsol_event = alc883_2ch_fujitsu_pi2515_unsol_event,
9048 		.init_hook = alc883_2ch_fujitsu_pi2515_automute,
9049 	},
9050 	[ALC888_FUJITSU_XA3530] = {
9051 		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
9052 		.init_verbs = { alc883_init_verbs,
9053 			alc888_fujitsu_xa3530_verbs },
9054 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9055 		.dac_nids = alc883_dac_nids,
9056 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9057 		.adc_nids = alc883_adc_nids_rev,
9058 		.capsrc_nids = alc883_capsrc_nids_rev,
9059 		.dig_out_nid = ALC883_DIGOUT_NID,
9060 		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9061 		.channel_mode = alc888_4ST_8ch_intel_modes,
9062 		.num_mux_defs =
9063 			ARRAY_SIZE(alc888_2_capture_sources),
9064 		.input_mux = alc888_2_capture_sources,
9065 		.unsol_event = alc888_fujitsu_xa3530_unsol_event,
9066 		.init_hook = alc888_fujitsu_xa3530_automute,
9067 	},
9068 	[ALC888_LENOVO_SKY] = {
9069 		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9070 		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9071 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9072 		.dac_nids = alc883_dac_nids,
9073 		.dig_out_nid = ALC883_DIGOUT_NID,
9074 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9075 		.channel_mode = alc883_sixstack_modes,
9076 		.need_dac_fix = 1,
9077 		.input_mux = &alc883_lenovo_sky_capture_source,
9078 		.unsol_event = alc883_lenovo_sky_unsol_event,
9079 		.init_hook = alc888_lenovo_sky_front_automute,
9080 	},
9081 	[ALC888_ASUS_M90V] = {
9082 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9083 		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9084 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9085 		.dac_nids = alc883_dac_nids,
9086 		.dig_out_nid = ALC883_DIGOUT_NID,
9087 		.dig_in_nid = ALC883_DIGIN_NID,
9088 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9089 		.channel_mode = alc883_3ST_6ch_modes,
9090 		.need_dac_fix = 1,
9091 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9092 		.unsol_event = alc883_mode2_unsol_event,
9093 		.init_hook = alc883_mode2_inithook,
9094 	},
9095 	[ALC888_ASUS_EEE1601] = {
9096 		.mixers = { alc883_asus_eee1601_mixer },
9097 		.cap_mixer = alc883_asus_eee1601_cap_mixer,
9098 		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9099 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9100 		.dac_nids = alc883_dac_nids,
9101 		.dig_out_nid = ALC883_DIGOUT_NID,
9102 		.dig_in_nid = ALC883_DIGIN_NID,
9103 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9104 		.channel_mode = alc883_3ST_2ch_modes,
9105 		.need_dac_fix = 1,
9106 		.input_mux = &alc883_asus_eee1601_capture_source,
9107 		.unsol_event = alc883_eee1601_unsol_event,
9108 		.init_hook = alc883_eee1601_inithook,
9109 	},
9110 	[ALC1200_ASUS_P5Q] = {
9111 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9112 		.init_verbs = { alc883_init_verbs },
9113 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9114 		.dac_nids = alc883_dac_nids,
9115 		.dig_out_nid = ALC1200_DIGOUT_NID,
9116 		.dig_in_nid = ALC883_DIGIN_NID,
9117 		.slave_dig_outs = alc1200_slave_dig_outs,
9118 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9119 		.channel_mode = alc883_sixstack_modes,
9120 		.input_mux = &alc883_capture_source,
9121 	},
9122 };
9123 
9124 
9125 /*
9126  * BIOS auto configuration
9127  */
9128 static void alc883_auto_set_output_and_unmute(struct hda_codec *codec,
9129 					      hda_nid_t nid, int pin_type,
9130 					      int dac_idx)
9131 {
9132 	/* set as output */
9133 	struct alc_spec *spec = codec->spec;
9134 	int idx;
9135 
9136 	alc_set_pin_output(codec, nid, pin_type);
9137 	if (spec->multiout.dac_nids[dac_idx] == 0x25)
9138 		idx = 4;
9139 	else
9140 		idx = spec->multiout.dac_nids[dac_idx] - 2;
9141 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9142 
9143 }
9144 
9145 static void alc883_auto_init_multi_out(struct hda_codec *codec)
9146 {
9147 	struct alc_spec *spec = codec->spec;
9148 	int i;
9149 
9150 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
9151 	for (i = 0; i <= HDA_SIDE; i++) {
9152 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
9153 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
9154 		if (nid)
9155 			alc883_auto_set_output_and_unmute(codec, nid, pin_type,
9156 							  i);
9157 	}
9158 }
9159 
9160 static void alc883_auto_init_hp_out(struct hda_codec *codec)
9161 {
9162 	struct alc_spec *spec = codec->spec;
9163 	hda_nid_t pin;
9164 
9165 	pin = spec->autocfg.hp_pins[0];
9166 	if (pin) /* connect to front */
9167 		/* use dac 0 */
9168 		alc883_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9169 	pin = spec->autocfg.speaker_pins[0];
9170 	if (pin)
9171 		alc883_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9172 }
9173 
9174 #define alc883_is_input_pin(nid)	alc880_is_input_pin(nid)
9175 #define ALC883_PIN_CD_NID		ALC880_PIN_CD_NID
9176 
9177 static void alc883_auto_init_analog_input(struct hda_codec *codec)
9178 {
9179 	struct alc_spec *spec = codec->spec;
9180 	int i;
9181 
9182 	for (i = 0; i < AUTO_PIN_LAST; i++) {
9183 		hda_nid_t nid = spec->autocfg.input_pins[i];
9184 		if (alc883_is_input_pin(nid)) {
9185 			alc_set_input_pin(codec, nid, i);
9186 			if (nid != ALC883_PIN_CD_NID &&
9187 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
9188 				snd_hda_codec_write(codec, nid, 0,
9189 						    AC_VERB_SET_AMP_GAIN_MUTE,
9190 						    AMP_OUT_MUTE);
9191 		}
9192 	}
9193 }
9194 
9195 #define alc883_auto_init_input_src	alc882_auto_init_input_src
9196 
9197 /* almost identical with ALC880 parser... */
9198 static int alc883_parse_auto_config(struct hda_codec *codec)
9199 {
9200 	struct alc_spec *spec = codec->spec;
9201 	int err = alc880_parse_auto_config(codec);
9202 	struct auto_pin_cfg *cfg = &spec->autocfg;
9203 	int i;
9204 
9205 	if (err < 0)
9206 		return err;
9207 	else if (!err)
9208 		return 0; /* no config found */
9209 
9210 	err = alc_auto_add_mic_boost(codec);
9211 	if (err < 0)
9212 		return err;
9213 
9214 	/* hack - override the init verbs */
9215 	spec->init_verbs[0] = alc883_auto_init_verbs;
9216 
9217 	/* setup input_mux for ALC889 */
9218 	if (codec->vendor_id == 0x10ec0889) {
9219 		/* digital-mic input pin is excluded in alc880_auto_create..()
9220 		 * because it's under 0x18
9221 		 */
9222 		if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9223 		    cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9224 			struct hda_input_mux *imux = &spec->private_imux[0];
9225 			for (i = 1; i < 3; i++)
9226 				memcpy(&spec->private_imux[i],
9227 				       &spec->private_imux[0],
9228 				       sizeof(spec->private_imux[0]));
9229 			imux->items[imux->num_items].label = "Int DMic";
9230 			imux->items[imux->num_items].index = 0x0b;
9231 			imux->num_items++;
9232 			spec->num_mux_defs = 3;
9233 			spec->input_mux = spec->private_imux;
9234 		}
9235 	}
9236 
9237 	return 1; /* config found */
9238 }
9239 
9240 /* additional initialization for auto-configuration model */
9241 static void alc883_auto_init(struct hda_codec *codec)
9242 {
9243 	struct alc_spec *spec = codec->spec;
9244 	alc883_auto_init_multi_out(codec);
9245 	alc883_auto_init_hp_out(codec);
9246 	alc883_auto_init_analog_input(codec);
9247 	alc883_auto_init_input_src(codec);
9248 	if (spec->unsol_event)
9249 		alc_inithook(codec);
9250 }
9251 
9252 static int patch_alc883(struct hda_codec *codec)
9253 {
9254 	struct alc_spec *spec;
9255 	int err, board_config;
9256 
9257 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9258 	if (spec == NULL)
9259 		return -ENOMEM;
9260 
9261 	codec->spec = spec;
9262 
9263 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9264 
9265 	board_config = snd_hda_check_board_config(codec, ALC883_MODEL_LAST,
9266 						  alc883_models,
9267 						  alc883_cfg_tbl);
9268 	if (board_config < 0) {
9269 		printk(KERN_INFO "hda_codec: Unknown model for ALC883, "
9270 		       "trying auto-probe from BIOS...\n");
9271 		board_config = ALC883_AUTO;
9272 	}
9273 
9274 	if (board_config == ALC883_AUTO) {
9275 		/* automatic parse from the BIOS config */
9276 		err = alc883_parse_auto_config(codec);
9277 		if (err < 0) {
9278 			alc_free(codec);
9279 			return err;
9280 		} else if (!err) {
9281 			printk(KERN_INFO
9282 			       "hda_codec: Cannot set up configuration "
9283 			       "from BIOS.  Using base mode...\n");
9284 			board_config = ALC883_3ST_2ch_DIG;
9285 		}
9286 	}
9287 
9288 	err = snd_hda_attach_beep_device(codec, 0x1);
9289 	if (err < 0) {
9290 		alc_free(codec);
9291 		return err;
9292 	}
9293 
9294 	if (board_config != ALC883_AUTO)
9295 		setup_preset(spec, &alc883_presets[board_config]);
9296 
9297 	switch (codec->vendor_id) {
9298 	case 0x10ec0888:
9299 		if (codec->revision_id == 0x100101) {
9300 			spec->stream_name_analog = "ALC1200 Analog";
9301 			spec->stream_name_digital = "ALC1200 Digital";
9302 		} else {
9303 			spec->stream_name_analog = "ALC888 Analog";
9304 			spec->stream_name_digital = "ALC888 Digital";
9305 		}
9306 		if (!spec->num_adc_nids) {
9307 			spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9308 			spec->adc_nids = alc883_adc_nids;
9309 		}
9310 		if (!spec->capsrc_nids)
9311 			spec->capsrc_nids = alc883_capsrc_nids;
9312 		spec->capture_style = CAPT_MIX; /* matrix-style capture */
9313 		break;
9314 	case 0x10ec0889:
9315 		spec->stream_name_analog = "ALC889 Analog";
9316 		spec->stream_name_digital = "ALC889 Digital";
9317 		if (!spec->num_adc_nids) {
9318 			spec->num_adc_nids = ARRAY_SIZE(alc889_adc_nids);
9319 			spec->adc_nids = alc889_adc_nids;
9320 		}
9321 		if (!spec->capsrc_nids)
9322 			spec->capsrc_nids = alc889_capsrc_nids;
9323 		spec->capture_style = CAPT_1MUX_MIX; /* 1mux/Nmix-style
9324 							capture */
9325 		break;
9326 	default:
9327 		spec->stream_name_analog = "ALC883 Analog";
9328 		spec->stream_name_digital = "ALC883 Digital";
9329 		if (!spec->num_adc_nids) {
9330 			spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
9331 			spec->adc_nids = alc883_adc_nids;
9332 		}
9333 		if (!spec->capsrc_nids)
9334 			spec->capsrc_nids = alc883_capsrc_nids;
9335 		spec->capture_style = CAPT_MIX; /* matrix-style capture */
9336 		break;
9337 	}
9338 
9339 	spec->stream_analog_playback = &alc883_pcm_analog_playback;
9340 	spec->stream_analog_capture = &alc883_pcm_analog_capture;
9341 	spec->stream_analog_alt_capture = &alc883_pcm_analog_alt_capture;
9342 
9343 	spec->stream_digital_playback = &alc883_pcm_digital_playback;
9344 	spec->stream_digital_capture = &alc883_pcm_digital_capture;
9345 
9346 	if (!spec->cap_mixer)
9347 		set_capture_mixer(spec);
9348 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9349 
9350 	spec->vmaster_nid = 0x0c;
9351 
9352 	codec->patch_ops = alc_patch_ops;
9353 	if (board_config == ALC883_AUTO)
9354 		spec->init_hook = alc883_auto_init;
9355 
9356 #ifdef CONFIG_SND_HDA_POWER_SAVE
9357 	if (!spec->loopback.amplist)
9358 		spec->loopback.amplist = alc883_loopbacks;
9359 #endif
9360 	codec->proc_widget_hook = print_realtek_coef;
9361 
9362 	return 0;
9363 }
9364 
9365 /*
9366  * ALC262 support
9367  */
9368 
9369 #define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
9370 #define ALC262_DIGIN_NID	ALC880_DIGIN_NID
9371 
9372 #define alc262_dac_nids		alc260_dac_nids
9373 #define alc262_adc_nids		alc882_adc_nids
9374 #define alc262_adc_nids_alt	alc882_adc_nids_alt
9375 #define alc262_capsrc_nids	alc882_capsrc_nids
9376 #define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
9377 
9378 #define alc262_modes		alc260_modes
9379 #define alc262_capture_source	alc882_capture_source
9380 
9381 static hda_nid_t alc262_dmic_adc_nids[1] = {
9382 	/* ADC0 */
9383 	0x09
9384 };
9385 
9386 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9387 
9388 static struct snd_kcontrol_new alc262_base_mixer[] = {
9389 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9390 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9391 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9392 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9393 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9394 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9395 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9396 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9397 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9398 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9399 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9400 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9401 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9402 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9403 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9404 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9405 	{ } /* end */
9406 };
9407 
9408 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9409 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9410 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9411 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9412 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9413 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9414 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9415 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9416 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9417 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9418 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9419 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9420 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9421 	/*HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),*/
9422 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9423 	{ } /* end */
9424 };
9425 
9426 /* update HP, line and mono-out pins according to the master switch */
9427 static void alc262_hp_master_update(struct hda_codec *codec)
9428 {
9429 	struct alc_spec *spec = codec->spec;
9430 	int val = spec->master_sw;
9431 
9432 	/* HP & line-out */
9433 	snd_hda_codec_write_cache(codec, 0x1b, 0,
9434 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
9435 				  val ? PIN_HP : 0);
9436 	snd_hda_codec_write_cache(codec, 0x15, 0,
9437 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
9438 				  val ? PIN_HP : 0);
9439 	/* mono (speaker) depending on the HP jack sense */
9440 	val = val && !spec->jack_present;
9441 	snd_hda_codec_write_cache(codec, 0x16, 0,
9442 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
9443 				  val ? PIN_OUT : 0);
9444 }
9445 
9446 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9447 {
9448 	struct alc_spec *spec = codec->spec;
9449 	unsigned int presence;
9450 	presence = snd_hda_codec_read(codec, 0x1b, 0,
9451 				      AC_VERB_GET_PIN_SENSE, 0);
9452 	spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9453 	alc262_hp_master_update(codec);
9454 }
9455 
9456 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9457 {
9458 	if ((res >> 26) != ALC880_HP_EVENT)
9459 		return;
9460 	alc262_hp_bpc_automute(codec);
9461 }
9462 
9463 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9464 {
9465 	struct alc_spec *spec = codec->spec;
9466 	unsigned int presence;
9467 	presence = snd_hda_codec_read(codec, 0x15, 0,
9468 				      AC_VERB_GET_PIN_SENSE, 0);
9469 	spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9470 	alc262_hp_master_update(codec);
9471 }
9472 
9473 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9474 					   unsigned int res)
9475 {
9476 	if ((res >> 26) != ALC880_HP_EVENT)
9477 		return;
9478 	alc262_hp_wildwest_automute(codec);
9479 }
9480 
9481 static int alc262_hp_master_sw_get(struct snd_kcontrol *kcontrol,
9482 				   struct snd_ctl_elem_value *ucontrol)
9483 {
9484 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9485 	struct alc_spec *spec = codec->spec;
9486 	*ucontrol->value.integer.value = spec->master_sw;
9487 	return 0;
9488 }
9489 
9490 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9491 				   struct snd_ctl_elem_value *ucontrol)
9492 {
9493 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9494 	struct alc_spec *spec = codec->spec;
9495 	int val = !!*ucontrol->value.integer.value;
9496 
9497 	if (val == spec->master_sw)
9498 		return 0;
9499 	spec->master_sw = val;
9500 	alc262_hp_master_update(codec);
9501 	return 1;
9502 }
9503 
9504 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9505 	{
9506 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9507 		.name = "Master Playback Switch",
9508 		.info = snd_ctl_boolean_mono_info,
9509 		.get = alc262_hp_master_sw_get,
9510 		.put = alc262_hp_master_sw_put,
9511 	},
9512 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9513 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9514 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9515 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9516 			      HDA_OUTPUT),
9517 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9518 			    HDA_OUTPUT),
9519 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9520 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9521 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9522 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9523 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9524 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9525 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9526 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9527 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9528 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9529 	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9530 	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9531 	{ } /* end */
9532 };
9533 
9534 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9535 	{
9536 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9537 		.name = "Master Playback Switch",
9538 		.info = snd_ctl_boolean_mono_info,
9539 		.get = alc262_hp_master_sw_get,
9540 		.put = alc262_hp_master_sw_put,
9541 	},
9542 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9543 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9544 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9545 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9546 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9547 			      HDA_OUTPUT),
9548 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9549 			    HDA_OUTPUT),
9550 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9551 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9552 	HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9553 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9554 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9555 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9556 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9557 	{ } /* end */
9558 };
9559 
9560 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9561 	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9562 	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9563 	HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9564 	{ } /* end */
9565 };
9566 
9567 /* mute/unmute internal speaker according to the hp jack and mute state */
9568 static void alc262_hp_t5735_automute(struct hda_codec *codec, int force)
9569 {
9570 	struct alc_spec *spec = codec->spec;
9571 
9572 	if (force || !spec->sense_updated) {
9573 		unsigned int present;
9574 		present = snd_hda_codec_read(codec, 0x15, 0,
9575 					     AC_VERB_GET_PIN_SENSE, 0);
9576 		spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
9577 		spec->sense_updated = 1;
9578 	}
9579 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0, HDA_AMP_MUTE,
9580 				 spec->jack_present ? HDA_AMP_MUTE : 0);
9581 }
9582 
9583 static void alc262_hp_t5735_unsol_event(struct hda_codec *codec,
9584 					unsigned int res)
9585 {
9586 	if ((res >> 26) != ALC880_HP_EVENT)
9587 		return;
9588 	alc262_hp_t5735_automute(codec, 1);
9589 }
9590 
9591 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9592 {
9593 	alc262_hp_t5735_automute(codec, 1);
9594 }
9595 
9596 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9597 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9598 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9599 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9600 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9601 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9602 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9603 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9604 	{ } /* end */
9605 };
9606 
9607 static struct hda_verb alc262_hp_t5735_verbs[] = {
9608 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9609 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9610 
9611 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9612 	{ }
9613 };
9614 
9615 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9616 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9617 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9618 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9619 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9620 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9621 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9622 	{ } /* end */
9623 };
9624 
9625 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9626 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9627 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9628 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9629 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9630 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9631 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9632 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9633 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9634 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9635 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9636 	{}
9637 };
9638 
9639 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9640 	.num_items = 1,
9641 	.items = {
9642 		{ "Line", 0x1 },
9643 	},
9644 };
9645 
9646 /* bind hp and internal speaker mute (with plug check) */
9647 static int alc262_sony_master_sw_put(struct snd_kcontrol *kcontrol,
9648 				     struct snd_ctl_elem_value *ucontrol)
9649 {
9650 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9651 	long *valp = ucontrol->value.integer.value;
9652 	int change;
9653 
9654 	/* change hp mute */
9655 	change = snd_hda_codec_amp_update(codec, 0x15, 0, HDA_OUTPUT, 0,
9656 					  HDA_AMP_MUTE,
9657 					  valp[0] ? 0 : HDA_AMP_MUTE);
9658 	change |= snd_hda_codec_amp_update(codec, 0x15, 1, HDA_OUTPUT, 0,
9659 					   HDA_AMP_MUTE,
9660 					   valp[1] ? 0 : HDA_AMP_MUTE);
9661 	if (change) {
9662 		/* change speaker according to HP jack state */
9663 		struct alc_spec *spec = codec->spec;
9664 		unsigned int mute;
9665 		if (spec->jack_present)
9666 			mute = HDA_AMP_MUTE;
9667 		else
9668 			mute = snd_hda_codec_amp_read(codec, 0x15, 0,
9669 						      HDA_OUTPUT, 0);
9670 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9671 					 HDA_AMP_MUTE, mute);
9672 	}
9673 	return change;
9674 }
9675 
9676 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9677 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9678 	{
9679 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9680 		.name = "Master Playback Switch",
9681 		.info = snd_hda_mixer_amp_switch_info,
9682 		.get = snd_hda_mixer_amp_switch_get,
9683 		.put = alc262_sony_master_sw_put,
9684 		.private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
9685 	},
9686 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9687 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9688 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9689 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9690 	{ } /* end */
9691 };
9692 
9693 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9694 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9695 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9696 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9697 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9698 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9699 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9700 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9701 	{ } /* end */
9702 };
9703 
9704 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9705 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9706 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9707 	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9708 	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9709 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9710 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9711 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9712 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9713 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9714 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9715 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9716 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9717 	{ } /* end */
9718 };
9719 
9720 static struct hda_verb alc262_tyan_verbs[] = {
9721 	/* Headphone automute */
9722 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9723 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9724 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9725 
9726 	/* P11 AUX_IN, white 4-pin connector */
9727 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9728 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9729 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9730 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9731 
9732 	{}
9733 };
9734 
9735 /* unsolicited event for HP jack sensing */
9736 static void alc262_tyan_automute(struct hda_codec *codec)
9737 {
9738 	unsigned int mute;
9739 	unsigned int present;
9740 
9741 	snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9742 	present = snd_hda_codec_read(codec, 0x1b, 0,
9743 				     AC_VERB_GET_PIN_SENSE, 0);
9744 	present = (present & 0x80000000) != 0;
9745 	if (present) {
9746 		/* mute line output on ATX panel */
9747 		snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9748 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
9749 	} else {
9750 		/* unmute line output if necessary */
9751 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9752 		snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9753 					 HDA_AMP_MUTE, mute);
9754 	}
9755 }
9756 
9757 static void alc262_tyan_unsol_event(struct hda_codec *codec,
9758 				       unsigned int res)
9759 {
9760 	if ((res >> 26) != ALC880_HP_EVENT)
9761 		return;
9762 	alc262_tyan_automute(codec);
9763 }
9764 
9765 #define alc262_capture_mixer		alc882_capture_mixer
9766 #define alc262_capture_alt_mixer	alc882_capture_alt_mixer
9767 
9768 /*
9769  * generic initialization of ADC, input mixers and output mixers
9770  */
9771 static struct hda_verb alc262_init_verbs[] = {
9772 	/*
9773 	 * Unmute ADC0-2 and set the default input to mic-in
9774 	 */
9775 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9776 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9777 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9778 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9779 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9780 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9781 
9782 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9783 	 * mixer widget
9784 	 * Note: PASD motherboards uses the Line In 2 as the input for
9785 	 * front panel mic (mic 2)
9786 	 */
9787 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9788 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9789 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9790 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9791 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9792 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9793 
9794 	/*
9795 	 * Set up output mixers (0x0c - 0x0e)
9796 	 */
9797 	/* set vol=0 to output mixers */
9798 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9799 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9800 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9801 	/* set up input amps for analog loopback */
9802 	/* Amp Indices: DAC = 0, mixer = 1 */
9803 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9804 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9805 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9806 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9807 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9808 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9809 
9810 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9811 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9812 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9813 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9814 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9815 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9816 
9817 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9818 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9819 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9820 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9821 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9822 
9823 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9824 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9825 
9826 	/* FIXME: use matrix-type input source selection */
9827 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9828 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9829 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9830 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9831 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9832 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9833 	/* Input mixer2 */
9834 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9835 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9836 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9837 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9838 	/* Input mixer3 */
9839 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9840 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9841 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9842 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9843 
9844 	{ }
9845 };
9846 
9847 static struct hda_verb alc262_eapd_verbs[] = {
9848 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9849 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9850 	{ }
9851 };
9852 
9853 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9854 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9855 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9856 	{}
9857 };
9858 
9859 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9860 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9861 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9862 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9863 
9864 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9865 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9866 	{}
9867 };
9868 
9869 static struct hda_verb alc262_sony_unsol_verbs[] = {
9870 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9871 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9872 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
9873 
9874 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9875 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9876 	{}
9877 };
9878 
9879 static struct hda_input_mux alc262_dmic_capture_source = {
9880 	.num_items = 2,
9881 	.items = {
9882 		{ "Int DMic", 0x9 },
9883 		{ "Mic", 0x0 },
9884 	},
9885 };
9886 
9887 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9888 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9889 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9890 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9891 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9892 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9893 	{ } /* end */
9894 };
9895 
9896 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9897 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9898 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9899 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9900 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9901 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9902 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9903 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9904 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9905 	{}
9906 };
9907 
9908 static void alc262_dmic_automute(struct hda_codec *codec)
9909 {
9910 	unsigned int present;
9911 
9912 	present = snd_hda_codec_read(codec, 0x18, 0,
9913 					AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9914 	snd_hda_codec_write(codec, 0x22, 0,
9915 				AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9916 }
9917 
9918 /* toggle speaker-output according to the hp-jack state */
9919 static void alc262_toshiba_s06_speaker_automute(struct hda_codec *codec)
9920 {
9921 	unsigned int present;
9922 	unsigned char bits;
9923 
9924 	present = snd_hda_codec_read(codec, 0x15, 0,
9925 					AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9926 	bits = present ? 0 : PIN_OUT;
9927 	snd_hda_codec_write(codec, 0x14, 0,
9928 					AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
9929 }
9930 
9931 
9932 
9933 /* unsolicited event for HP jack sensing */
9934 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9935 				       unsigned int res)
9936 {
9937 	if ((res >> 26) == ALC880_HP_EVENT)
9938 		alc262_toshiba_s06_speaker_automute(codec);
9939 	if ((res >> 26) == ALC880_MIC_EVENT)
9940 		alc262_dmic_automute(codec);
9941 
9942 }
9943 
9944 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9945 {
9946 	alc262_toshiba_s06_speaker_automute(codec);
9947 	alc262_dmic_automute(codec);
9948 }
9949 
9950 /* mute/unmute internal speaker according to the hp jack and mute state */
9951 static void alc262_hippo_automute(struct hda_codec *codec)
9952 {
9953 	struct alc_spec *spec = codec->spec;
9954 	unsigned int mute;
9955 	unsigned int present;
9956 
9957 	/* need to execute and sync at first */
9958 	snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
9959 	present = snd_hda_codec_read(codec, 0x15, 0,
9960 				     AC_VERB_GET_PIN_SENSE, 0);
9961 	spec->jack_present = (present & 0x80000000) != 0;
9962 	if (spec->jack_present) {
9963 		/* mute internal speaker */
9964 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9965 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
9966 	} else {
9967 		/* unmute internal speaker if necessary */
9968 		mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
9969 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9970 					 HDA_AMP_MUTE, mute);
9971 	}
9972 }
9973 
9974 /* unsolicited event for HP jack sensing */
9975 static void alc262_hippo_unsol_event(struct hda_codec *codec,
9976 				       unsigned int res)
9977 {
9978 	if ((res >> 26) != ALC880_HP_EVENT)
9979 		return;
9980 	alc262_hippo_automute(codec);
9981 }
9982 
9983 static void alc262_hippo1_automute(struct hda_codec *codec)
9984 {
9985 	unsigned int mute;
9986 	unsigned int present;
9987 
9988 	snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
9989 	present = snd_hda_codec_read(codec, 0x1b, 0,
9990 				     AC_VERB_GET_PIN_SENSE, 0);
9991 	present = (present & 0x80000000) != 0;
9992 	if (present) {
9993 		/* mute internal speaker */
9994 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9995 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
9996 	} else {
9997 		/* unmute internal speaker if necessary */
9998 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
9999 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10000 					 HDA_AMP_MUTE, mute);
10001 	}
10002 }
10003 
10004 /* unsolicited event for HP jack sensing */
10005 static void alc262_hippo1_unsol_event(struct hda_codec *codec,
10006 				       unsigned int res)
10007 {
10008 	if ((res >> 26) != ALC880_HP_EVENT)
10009 		return;
10010 	alc262_hippo1_automute(codec);
10011 }
10012 
10013 /*
10014  * nec model
10015  *  0x15 = headphone
10016  *  0x16 = internal speaker
10017  *  0x18 = external mic
10018  */
10019 
10020 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10021 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10022 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10023 
10024 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10025 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10026 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10027 
10028 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10029 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10030 	{ } /* end */
10031 };
10032 
10033 static struct hda_verb alc262_nec_verbs[] = {
10034 	/* Unmute Speaker */
10035 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10036 
10037 	/* Headphone */
10038 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10039 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10040 
10041 	/* External mic to headphone */
10042 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10043 	/* External mic to speaker */
10044 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10045 	{}
10046 };
10047 
10048 /*
10049  * fujitsu model
10050  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10051  *  0x1b = port replicator headphone out
10052  */
10053 
10054 #define ALC_HP_EVENT	0x37
10055 
10056 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10057 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10058 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10059 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10060 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10061 	{}
10062 };
10063 
10064 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10065 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10066 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10067 	{}
10068 };
10069 
10070 static struct hda_input_mux alc262_fujitsu_capture_source = {
10071 	.num_items = 3,
10072 	.items = {
10073 		{ "Mic", 0x0 },
10074 		{ "Int Mic", 0x1 },
10075 		{ "CD", 0x4 },
10076 	},
10077 };
10078 
10079 static struct hda_input_mux alc262_HP_capture_source = {
10080 	.num_items = 5,
10081 	.items = {
10082 		{ "Mic", 0x0 },
10083 		{ "Front Mic", 0x1 },
10084 		{ "Line", 0x2 },
10085 		{ "CD", 0x4 },
10086 		{ "AUX IN", 0x6 },
10087 	},
10088 };
10089 
10090 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10091 	.num_items = 4,
10092 	.items = {
10093 		{ "Mic", 0x0 },
10094 		{ "Front Mic", 0x2 },
10095 		{ "Line", 0x1 },
10096 		{ "CD", 0x4 },
10097 	},
10098 };
10099 
10100 /* mute/unmute internal speaker according to the hp jacks and mute state */
10101 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10102 {
10103 	struct alc_spec *spec = codec->spec;
10104 	unsigned int mute;
10105 
10106 	if (force || !spec->sense_updated) {
10107 		unsigned int present;
10108 		/* need to execute and sync at first */
10109 		snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10110 		/* check laptop HP jack */
10111 		present = snd_hda_codec_read(codec, 0x14, 0,
10112 					     AC_VERB_GET_PIN_SENSE, 0);
10113 		/* need to execute and sync at first */
10114 		snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10115 		/* check docking HP jack */
10116 		present |= snd_hda_codec_read(codec, 0x1b, 0,
10117 					      AC_VERB_GET_PIN_SENSE, 0);
10118 		if (present & AC_PINSENSE_PRESENCE)
10119 			spec->jack_present = 1;
10120 		else
10121 			spec->jack_present = 0;
10122 		spec->sense_updated = 1;
10123 	}
10124 	/* unmute internal speaker only if both HPs are unplugged and
10125 	 * master switch is on
10126 	 */
10127 	if (spec->jack_present)
10128 		mute = HDA_AMP_MUTE;
10129 	else
10130 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10131 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10132 				 HDA_AMP_MUTE, mute);
10133 }
10134 
10135 /* unsolicited event for HP jack sensing */
10136 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10137 				       unsigned int res)
10138 {
10139 	if ((res >> 26) != ALC_HP_EVENT)
10140 		return;
10141 	alc262_fujitsu_automute(codec, 1);
10142 }
10143 
10144 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10145 {
10146 	alc262_fujitsu_automute(codec, 1);
10147 }
10148 
10149 /* bind volumes of both NID 0x0c and 0x0d */
10150 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10151 	.ops = &snd_hda_bind_vol,
10152 	.values = {
10153 		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10154 		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10155 		0
10156 	},
10157 };
10158 
10159 /* mute/unmute internal speaker according to the hp jack and mute state */
10160 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10161 {
10162 	struct alc_spec *spec = codec->spec;
10163 	unsigned int mute;
10164 
10165 	if (force || !spec->sense_updated) {
10166 		unsigned int present_int_hp;
10167 		/* need to execute and sync at first */
10168 		snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10169 		present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10170 					AC_VERB_GET_PIN_SENSE, 0);
10171 		spec->jack_present = (present_int_hp & 0x80000000) != 0;
10172 		spec->sense_updated = 1;
10173 	}
10174 	if (spec->jack_present) {
10175 		/* mute internal speaker */
10176 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10177 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
10178 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10179 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
10180 	} else {
10181 		/* unmute internal speaker if necessary */
10182 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10183 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10184 					 HDA_AMP_MUTE, mute);
10185 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10186 					 HDA_AMP_MUTE, mute);
10187 	}
10188 }
10189 
10190 /* unsolicited event for HP jack sensing */
10191 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10192 				       unsigned int res)
10193 {
10194 	if ((res >> 26) != ALC_HP_EVENT)
10195 		return;
10196 	alc262_lenovo_3000_automute(codec, 1);
10197 }
10198 
10199 /* bind hp and internal speaker mute (with plug check) */
10200 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10201 					 struct snd_ctl_elem_value *ucontrol)
10202 {
10203 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10204 	long *valp = ucontrol->value.integer.value;
10205 	int change;
10206 
10207 	change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10208 						 HDA_AMP_MUTE,
10209 						 valp ? 0 : HDA_AMP_MUTE);
10210 	change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10211 						 HDA_AMP_MUTE,
10212 						 valp ? 0 : HDA_AMP_MUTE);
10213 
10214 	if (change)
10215 		alc262_fujitsu_automute(codec, 0);
10216 	return change;
10217 }
10218 
10219 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10220 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10221 	{
10222 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10223 		.name = "Master Playback Switch",
10224 		.info = snd_hda_mixer_amp_switch_info,
10225 		.get = snd_hda_mixer_amp_switch_get,
10226 		.put = alc262_fujitsu_master_sw_put,
10227 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10228 	},
10229 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10230 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10231 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10232 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10233 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10234 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10235 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10236 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10237 	{ } /* end */
10238 };
10239 
10240 /* bind hp and internal speaker mute (with plug check) */
10241 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10242 					 struct snd_ctl_elem_value *ucontrol)
10243 {
10244 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10245 	long *valp = ucontrol->value.integer.value;
10246 	int change;
10247 
10248 	change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10249 						 HDA_AMP_MUTE,
10250 						 valp ? 0 : HDA_AMP_MUTE);
10251 
10252 	if (change)
10253 		alc262_lenovo_3000_automute(codec, 0);
10254 	return change;
10255 }
10256 
10257 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10258 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10259 	{
10260 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10261 		.name = "Master Playback Switch",
10262 		.info = snd_hda_mixer_amp_switch_info,
10263 		.get = snd_hda_mixer_amp_switch_get,
10264 		.put = alc262_lenovo_3000_master_sw_put,
10265 		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10266 	},
10267 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10268 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10269 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10270 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10271 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10272 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10273 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10274 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10275 	{ } /* end */
10276 };
10277 
10278 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10279 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10280 	{
10281 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10282 		.name = "Master Playback Switch",
10283 		.info = snd_hda_mixer_amp_switch_info,
10284 		.get = snd_hda_mixer_amp_switch_get,
10285 		.put = alc262_sony_master_sw_put,
10286 		.private_value = HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
10287 	},
10288 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10289 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10290 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10291 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10292 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10293 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10294 	{ } /* end */
10295 };
10296 
10297 /* additional init verbs for Benq laptops */
10298 static struct hda_verb alc262_EAPD_verbs[] = {
10299 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10300 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10301 	{}
10302 };
10303 
10304 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10305 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10306 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10307 
10308 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10309 	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10310 	{}
10311 };
10312 
10313 /* Samsung Q1 Ultra Vista model setup */
10314 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10315 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10316 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10317 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10318 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10319 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10320 	HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10321 	{ } /* end */
10322 };
10323 
10324 static struct hda_verb alc262_ultra_verbs[] = {
10325 	/* output mixer */
10326 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10327 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10328 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10329 	/* speaker */
10330 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10331 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10332 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10333 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10334 	/* HP */
10335 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10336 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10337 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10338 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10339 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10340 	/* internal mic */
10341 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10342 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10343 	/* ADC, choose mic */
10344 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10345 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10346 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10347 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10348 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10349 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10350 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10351 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10352 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10353 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10354 	{}
10355 };
10356 
10357 /* mute/unmute internal speaker according to the hp jack and mute state */
10358 static void alc262_ultra_automute(struct hda_codec *codec)
10359 {
10360 	struct alc_spec *spec = codec->spec;
10361 	unsigned int mute;
10362 
10363 	mute = 0;
10364 	/* auto-mute only when HP is used as HP */
10365 	if (!spec->cur_mux[0]) {
10366 		unsigned int present;
10367 		/* need to execute and sync at first */
10368 		snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10369 		present = snd_hda_codec_read(codec, 0x15, 0,
10370 					     AC_VERB_GET_PIN_SENSE, 0);
10371 		spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10372 		if (spec->jack_present)
10373 			mute = HDA_AMP_MUTE;
10374 	}
10375 	/* mute/unmute internal speaker */
10376 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10377 				 HDA_AMP_MUTE, mute);
10378 	/* mute/unmute HP */
10379 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10380 				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10381 }
10382 
10383 /* unsolicited event for HP jack sensing */
10384 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10385 				       unsigned int res)
10386 {
10387 	if ((res >> 26) != ALC880_HP_EVENT)
10388 		return;
10389 	alc262_ultra_automute(codec);
10390 }
10391 
10392 static struct hda_input_mux alc262_ultra_capture_source = {
10393 	.num_items = 2,
10394 	.items = {
10395 		{ "Mic", 0x1 },
10396 		{ "Headphone", 0x7 },
10397 	},
10398 };
10399 
10400 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10401 				     struct snd_ctl_elem_value *ucontrol)
10402 {
10403 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10404 	struct alc_spec *spec = codec->spec;
10405 	int ret;
10406 
10407 	ret = alc_mux_enum_put(kcontrol, ucontrol);
10408 	if (!ret)
10409 		return 0;
10410 	/* reprogram the HP pin as mic or HP according to the input source */
10411 	snd_hda_codec_write_cache(codec, 0x15, 0,
10412 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10413 				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10414 	alc262_ultra_automute(codec); /* mute/unmute HP */
10415 	return ret;
10416 }
10417 
10418 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10419 	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10420 	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10421 	{
10422 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10423 		.name = "Capture Source",
10424 		.info = alc_mux_enum_info,
10425 		.get = alc_mux_enum_get,
10426 		.put = alc262_ultra_mux_enum_put,
10427 	},
10428 	{ } /* end */
10429 };
10430 
10431 /* add playback controls from the parsed DAC table */
10432 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10433 					     const struct auto_pin_cfg *cfg)
10434 {
10435 	hda_nid_t nid;
10436 	int err;
10437 
10438 	spec->multiout.num_dacs = 1;	/* only use one dac */
10439 	spec->multiout.dac_nids = spec->private_dac_nids;
10440 	spec->multiout.dac_nids[0] = 2;
10441 
10442 	nid = cfg->line_out_pins[0];
10443 	if (nid) {
10444 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
10445 				  "Front Playback Volume",
10446 				  HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10447 		if (err < 0)
10448 			return err;
10449 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10450 				  "Front Playback Switch",
10451 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10452 		if (err < 0)
10453 			return err;
10454 	}
10455 
10456 	nid = cfg->speaker_pins[0];
10457 	if (nid) {
10458 		if (nid == 0x16) {
10459 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
10460 					  "Speaker Playback Volume",
10461 					  HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10462 							      HDA_OUTPUT));
10463 			if (err < 0)
10464 				return err;
10465 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10466 					  "Speaker Playback Switch",
10467 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10468 							      HDA_OUTPUT));
10469 			if (err < 0)
10470 				return err;
10471 		} else {
10472 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10473 					  "Speaker Playback Switch",
10474 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10475 							      HDA_OUTPUT));
10476 			if (err < 0)
10477 				return err;
10478 		}
10479 	}
10480 	nid = cfg->hp_pins[0];
10481 	if (nid) {
10482 		/* spec->multiout.hp_nid = 2; */
10483 		if (nid == 0x16) {
10484 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
10485 					  "Headphone Playback Volume",
10486 					  HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10487 							      HDA_OUTPUT));
10488 			if (err < 0)
10489 				return err;
10490 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10491 					  "Headphone Playback Switch",
10492 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10493 							      HDA_OUTPUT));
10494 			if (err < 0)
10495 				return err;
10496 		} else {
10497 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10498 					  "Headphone Playback Switch",
10499 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10500 							      HDA_OUTPUT));
10501 			if (err < 0)
10502 				return err;
10503 		}
10504 	}
10505 	return 0;
10506 }
10507 
10508 /* identical with ALC880 */
10509 #define alc262_auto_create_analog_input_ctls \
10510 	alc880_auto_create_analog_input_ctls
10511 
10512 /*
10513  * generic initialization of ADC, input mixers and output mixers
10514  */
10515 static struct hda_verb alc262_volume_init_verbs[] = {
10516 	/*
10517 	 * Unmute ADC0-2 and set the default input to mic-in
10518 	 */
10519 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10520 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10521 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10522 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10523 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10524 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10525 
10526 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10527 	 * mixer widget
10528 	 * Note: PASD motherboards uses the Line In 2 as the input for
10529 	 * front panel mic (mic 2)
10530 	 */
10531 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10532 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10533 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10534 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10535 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10536 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10537 
10538 	/*
10539 	 * Set up output mixers (0x0c - 0x0f)
10540 	 */
10541 	/* set vol=0 to output mixers */
10542 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10543 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10544 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10545 
10546 	/* set up input amps for analog loopback */
10547 	/* Amp Indices: DAC = 0, mixer = 1 */
10548 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10549 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10550 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10551 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10552 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10553 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10554 
10555 	/* FIXME: use matrix-type input source selection */
10556 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10557 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10558 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10559 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10560 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10561 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10562 	/* Input mixer2 */
10563 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10564 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10565 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10566 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10567 	/* Input mixer3 */
10568 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10569 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10570 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10571 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10572 
10573 	{ }
10574 };
10575 
10576 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10577 	/*
10578 	 * Unmute ADC0-2 and set the default input to mic-in
10579 	 */
10580 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10581 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10582 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10583 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10584 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10585 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10586 
10587 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10588 	 * mixer widget
10589 	 * Note: PASD motherboards uses the Line In 2 as the input for
10590 	 * front panel mic (mic 2)
10591 	 */
10592 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10593 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10594 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10595 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10596 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10597 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10598 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10599         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10600 
10601 	/*
10602 	 * Set up output mixers (0x0c - 0x0e)
10603 	 */
10604 	/* set vol=0 to output mixers */
10605 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10606 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10607 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10608 
10609 	/* set up input amps for analog loopback */
10610 	/* Amp Indices: DAC = 0, mixer = 1 */
10611 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10612 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10613 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10614 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10615 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10616 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10617 
10618 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10619 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10620 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10621 
10622 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10623 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10624 
10625 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10626 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10627 
10628 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10629 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10630         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10631 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10632 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10633 
10634 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10635 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10636         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10637 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10638 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10639 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10640 
10641 
10642 	/* FIXME: use matrix-type input source selection */
10643 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10644 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10645 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10646 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10647 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10648 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10649 	/* Input mixer2 */
10650 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10651 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10652 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10653 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10654 	/* Input mixer3 */
10655 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10656 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10657 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10658 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10659 
10660 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10661 
10662 	{ }
10663 };
10664 
10665 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10666 	/*
10667 	 * Unmute ADC0-2 and set the default input to mic-in
10668 	 */
10669 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10670 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10671 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10672 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10673 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10674 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10675 
10676 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10677 	 * mixer widget
10678 	 * Note: PASD motherboards uses the Line In 2 as the input for front
10679 	 * panel mic (mic 2)
10680 	 */
10681 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10682 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10683 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10684 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10685 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10686 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10687 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10688 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10689 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10690 	/*
10691 	 * Set up output mixers (0x0c - 0x0e)
10692 	 */
10693 	/* set vol=0 to output mixers */
10694 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10695 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10696 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10697 
10698 	/* set up input amps for analog loopback */
10699 	/* Amp Indices: DAC = 0, mixer = 1 */
10700 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10701 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10702 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10703 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10704 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10705 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10706 
10707 
10708 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
10709 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
10710 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
10711 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
10712 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
10713 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
10714 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
10715 
10716 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10717 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10718 
10719 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10720 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10721 
10722 	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10723 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10724 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10725 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10726 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10727 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10728 
10729 	/* FIXME: use matrix-type input source selection */
10730 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10731 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10732 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10733 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10734 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10735 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10736 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10737         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10738 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10739 	/* Input mixer2 */
10740 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10741 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10742 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10743 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10744 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10745         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10746 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10747 	/* Input mixer3 */
10748 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10749 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10750 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10751 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10752 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10753         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10754 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10755 
10756 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10757 
10758 	{ }
10759 };
10760 
10761 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10762 
10763 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
10764 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10765 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10766 
10767 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
10768 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
10769 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10770 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10771 
10772 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
10773 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10774 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10775 	{}
10776 };
10777 
10778 
10779 #ifdef CONFIG_SND_HDA_POWER_SAVE
10780 #define alc262_loopbacks	alc880_loopbacks
10781 #endif
10782 
10783 /* pcm configuration: identiacal with ALC880 */
10784 #define alc262_pcm_analog_playback	alc880_pcm_analog_playback
10785 #define alc262_pcm_analog_capture	alc880_pcm_analog_capture
10786 #define alc262_pcm_digital_playback	alc880_pcm_digital_playback
10787 #define alc262_pcm_digital_capture	alc880_pcm_digital_capture
10788 
10789 /*
10790  * BIOS auto configuration
10791  */
10792 static int alc262_parse_auto_config(struct hda_codec *codec)
10793 {
10794 	struct alc_spec *spec = codec->spec;
10795 	int err;
10796 	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10797 
10798 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10799 					   alc262_ignore);
10800 	if (err < 0)
10801 		return err;
10802 	if (!spec->autocfg.line_outs) {
10803 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10804 			spec->multiout.max_channels = 2;
10805 			spec->no_analog = 1;
10806 			goto dig_only;
10807 		}
10808 		return 0; /* can't find valid BIOS pin config */
10809 	}
10810 	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10811 	if (err < 0)
10812 		return err;
10813 	err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10814 	if (err < 0)
10815 		return err;
10816 
10817 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10818 
10819  dig_only:
10820 	if (spec->autocfg.dig_outs) {
10821 		spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10822 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
10823 	}
10824 	if (spec->autocfg.dig_in_pin)
10825 		spec->dig_in_nid = ALC262_DIGIN_NID;
10826 
10827 	if (spec->kctls.list)
10828 		add_mixer(spec, spec->kctls.list);
10829 
10830 	add_verb(spec, alc262_volume_init_verbs);
10831 	spec->num_mux_defs = 1;
10832 	spec->input_mux = &spec->private_imux[0];
10833 
10834 	err = alc_auto_add_mic_boost(codec);
10835 	if (err < 0)
10836 		return err;
10837 
10838 	return 1;
10839 }
10840 
10841 #define alc262_auto_init_multi_out	alc882_auto_init_multi_out
10842 #define alc262_auto_init_hp_out		alc882_auto_init_hp_out
10843 #define alc262_auto_init_analog_input	alc882_auto_init_analog_input
10844 #define alc262_auto_init_input_src	alc882_auto_init_input_src
10845 
10846 
10847 /* init callback for auto-configuration model -- overriding the default init */
10848 static void alc262_auto_init(struct hda_codec *codec)
10849 {
10850 	struct alc_spec *spec = codec->spec;
10851 	alc262_auto_init_multi_out(codec);
10852 	alc262_auto_init_hp_out(codec);
10853 	alc262_auto_init_analog_input(codec);
10854 	alc262_auto_init_input_src(codec);
10855 	if (spec->unsol_event)
10856 		alc_inithook(codec);
10857 }
10858 
10859 /*
10860  * configuration and preset
10861  */
10862 static const char *alc262_models[ALC262_MODEL_LAST] = {
10863 	[ALC262_BASIC]		= "basic",
10864 	[ALC262_HIPPO]		= "hippo",
10865 	[ALC262_HIPPO_1]	= "hippo_1",
10866 	[ALC262_FUJITSU]	= "fujitsu",
10867 	[ALC262_HP_BPC]		= "hp-bpc",
10868 	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10869 	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
10870 	[ALC262_HP_RP5700]	= "hp-rp5700",
10871 	[ALC262_BENQ_ED8]	= "benq",
10872 	[ALC262_BENQ_T31]	= "benq-t31",
10873 	[ALC262_SONY_ASSAMD]	= "sony-assamd",
10874 	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
10875 	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
10876 	[ALC262_ULTRA]		= "ultra",
10877 	[ALC262_LENOVO_3000]	= "lenovo-3000",
10878 	[ALC262_NEC]		= "nec",
10879 	[ALC262_TYAN]		= "tyan",
10880 	[ALC262_AUTO]		= "auto",
10881 };
10882 
10883 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10884 	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10885 	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10886 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10887 			   ALC262_HP_BPC),
10888 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10889 			   ALC262_HP_BPC),
10890 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10891 			   ALC262_HP_BPC),
10892 	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10893 	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10894 	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10895 	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10896 	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10897 	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10898 	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10899 	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10900 	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10901 	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10902 	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10903 	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10904 		      ALC262_HP_TC_T5735),
10905 	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10906 	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10907 	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10908 	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10909 	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10910 	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10911 			   ALC262_SONY_ASSAMD),
10912 	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10913 		      ALC262_TOSHIBA_RX1),
10914 	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10915 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10916 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10917 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10918 	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10919 			   ALC262_ULTRA),
10920 	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10921 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10922 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10923 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10924 	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10925 	{}
10926 };
10927 
10928 static struct alc_config_preset alc262_presets[] = {
10929 	[ALC262_BASIC] = {
10930 		.mixers = { alc262_base_mixer },
10931 		.init_verbs = { alc262_init_verbs },
10932 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10933 		.dac_nids = alc262_dac_nids,
10934 		.hp_nid = 0x03,
10935 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10936 		.channel_mode = alc262_modes,
10937 		.input_mux = &alc262_capture_source,
10938 	},
10939 	[ALC262_HIPPO] = {
10940 		.mixers = { alc262_base_mixer },
10941 		.init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10942 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10943 		.dac_nids = alc262_dac_nids,
10944 		.hp_nid = 0x03,
10945 		.dig_out_nid = ALC262_DIGOUT_NID,
10946 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10947 		.channel_mode = alc262_modes,
10948 		.input_mux = &alc262_capture_source,
10949 		.unsol_event = alc262_hippo_unsol_event,
10950 		.init_hook = alc262_hippo_automute,
10951 	},
10952 	[ALC262_HIPPO_1] = {
10953 		.mixers = { alc262_hippo1_mixer },
10954 		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10955 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10956 		.dac_nids = alc262_dac_nids,
10957 		.hp_nid = 0x02,
10958 		.dig_out_nid = ALC262_DIGOUT_NID,
10959 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10960 		.channel_mode = alc262_modes,
10961 		.input_mux = &alc262_capture_source,
10962 		.unsol_event = alc262_hippo1_unsol_event,
10963 		.init_hook = alc262_hippo1_automute,
10964 	},
10965 	[ALC262_FUJITSU] = {
10966 		.mixers = { alc262_fujitsu_mixer },
10967 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10968 				alc262_fujitsu_unsol_verbs },
10969 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10970 		.dac_nids = alc262_dac_nids,
10971 		.hp_nid = 0x03,
10972 		.dig_out_nid = ALC262_DIGOUT_NID,
10973 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10974 		.channel_mode = alc262_modes,
10975 		.input_mux = &alc262_fujitsu_capture_source,
10976 		.unsol_event = alc262_fujitsu_unsol_event,
10977 		.init_hook = alc262_fujitsu_init_hook,
10978 	},
10979 	[ALC262_HP_BPC] = {
10980 		.mixers = { alc262_HP_BPC_mixer },
10981 		.init_verbs = { alc262_HP_BPC_init_verbs },
10982 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10983 		.dac_nids = alc262_dac_nids,
10984 		.hp_nid = 0x03,
10985 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10986 		.channel_mode = alc262_modes,
10987 		.input_mux = &alc262_HP_capture_source,
10988 		.unsol_event = alc262_hp_bpc_unsol_event,
10989 		.init_hook = alc262_hp_bpc_automute,
10990 	},
10991 	[ALC262_HP_BPC_D7000_WF] = {
10992 		.mixers = { alc262_HP_BPC_WildWest_mixer },
10993 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
10994 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
10995 		.dac_nids = alc262_dac_nids,
10996 		.hp_nid = 0x03,
10997 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
10998 		.channel_mode = alc262_modes,
10999 		.input_mux = &alc262_HP_D7000_capture_source,
11000 		.unsol_event = alc262_hp_wildwest_unsol_event,
11001 		.init_hook = alc262_hp_wildwest_automute,
11002 	},
11003 	[ALC262_HP_BPC_D7000_WL] = {
11004 		.mixers = { alc262_HP_BPC_WildWest_mixer,
11005 			    alc262_HP_BPC_WildWest_option_mixer },
11006 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11007 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11008 		.dac_nids = alc262_dac_nids,
11009 		.hp_nid = 0x03,
11010 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11011 		.channel_mode = alc262_modes,
11012 		.input_mux = &alc262_HP_D7000_capture_source,
11013 		.unsol_event = alc262_hp_wildwest_unsol_event,
11014 		.init_hook = alc262_hp_wildwest_automute,
11015 	},
11016 	[ALC262_HP_TC_T5735] = {
11017 		.mixers = { alc262_hp_t5735_mixer },
11018 		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11019 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11020 		.dac_nids = alc262_dac_nids,
11021 		.hp_nid = 0x03,
11022 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11023 		.channel_mode = alc262_modes,
11024 		.input_mux = &alc262_capture_source,
11025 		.unsol_event = alc262_hp_t5735_unsol_event,
11026 		.init_hook = alc262_hp_t5735_init_hook,
11027 	},
11028 	[ALC262_HP_RP5700] = {
11029 		.mixers = { alc262_hp_rp5700_mixer },
11030 		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11031 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11032 		.dac_nids = alc262_dac_nids,
11033 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11034 		.channel_mode = alc262_modes,
11035 		.input_mux = &alc262_hp_rp5700_capture_source,
11036         },
11037 	[ALC262_BENQ_ED8] = {
11038 		.mixers = { alc262_base_mixer },
11039 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11040 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11041 		.dac_nids = alc262_dac_nids,
11042 		.hp_nid = 0x03,
11043 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11044 		.channel_mode = alc262_modes,
11045 		.input_mux = &alc262_capture_source,
11046 	},
11047 	[ALC262_SONY_ASSAMD] = {
11048 		.mixers = { alc262_sony_mixer },
11049 		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11050 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11051 		.dac_nids = alc262_dac_nids,
11052 		.hp_nid = 0x02,
11053 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11054 		.channel_mode = alc262_modes,
11055 		.input_mux = &alc262_capture_source,
11056 		.unsol_event = alc262_hippo_unsol_event,
11057 		.init_hook = alc262_hippo_automute,
11058 	},
11059 	[ALC262_BENQ_T31] = {
11060 		.mixers = { alc262_benq_t31_mixer },
11061 		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11062 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11063 		.dac_nids = alc262_dac_nids,
11064 		.hp_nid = 0x03,
11065 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11066 		.channel_mode = alc262_modes,
11067 		.input_mux = &alc262_capture_source,
11068 		.unsol_event = alc262_hippo_unsol_event,
11069 		.init_hook = alc262_hippo_automute,
11070 	},
11071 	[ALC262_ULTRA] = {
11072 		.mixers = { alc262_ultra_mixer },
11073 		.cap_mixer = alc262_ultra_capture_mixer,
11074 		.init_verbs = { alc262_ultra_verbs },
11075 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11076 		.dac_nids = alc262_dac_nids,
11077 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11078 		.channel_mode = alc262_modes,
11079 		.input_mux = &alc262_ultra_capture_source,
11080 		.adc_nids = alc262_adc_nids, /* ADC0 */
11081 		.capsrc_nids = alc262_capsrc_nids,
11082 		.num_adc_nids = 1, /* single ADC */
11083 		.unsol_event = alc262_ultra_unsol_event,
11084 		.init_hook = alc262_ultra_automute,
11085 	},
11086 	[ALC262_LENOVO_3000] = {
11087 		.mixers = { alc262_lenovo_3000_mixer },
11088 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11089 				alc262_lenovo_3000_unsol_verbs },
11090 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11091 		.dac_nids = alc262_dac_nids,
11092 		.hp_nid = 0x03,
11093 		.dig_out_nid = ALC262_DIGOUT_NID,
11094 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11095 		.channel_mode = alc262_modes,
11096 		.input_mux = &alc262_fujitsu_capture_source,
11097 		.unsol_event = alc262_lenovo_3000_unsol_event,
11098 	},
11099 	[ALC262_NEC] = {
11100 		.mixers = { alc262_nec_mixer },
11101 		.init_verbs = { alc262_nec_verbs },
11102 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11103 		.dac_nids = alc262_dac_nids,
11104 		.hp_nid = 0x03,
11105 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11106 		.channel_mode = alc262_modes,
11107 		.input_mux = &alc262_capture_source,
11108 	},
11109 	[ALC262_TOSHIBA_S06] = {
11110 		.mixers = { alc262_toshiba_s06_mixer },
11111 		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11112 							alc262_eapd_verbs },
11113 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11114 		.capsrc_nids = alc262_dmic_capsrc_nids,
11115 		.dac_nids = alc262_dac_nids,
11116 		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11117 		.dig_out_nid = ALC262_DIGOUT_NID,
11118 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11119 		.channel_mode = alc262_modes,
11120 		.input_mux = &alc262_dmic_capture_source,
11121 		.unsol_event = alc262_toshiba_s06_unsol_event,
11122 		.init_hook = alc262_toshiba_s06_init_hook,
11123 	},
11124 	[ALC262_TOSHIBA_RX1] = {
11125 		.mixers = { alc262_toshiba_rx1_mixer },
11126 		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11127 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11128 		.dac_nids = alc262_dac_nids,
11129 		.hp_nid = 0x03,
11130 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11131 		.channel_mode = alc262_modes,
11132 		.input_mux = &alc262_capture_source,
11133 		.unsol_event = alc262_hippo_unsol_event,
11134 		.init_hook = alc262_hippo_automute,
11135 	},
11136 	[ALC262_TYAN] = {
11137 		.mixers = { alc262_tyan_mixer },
11138 		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11139 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11140 		.dac_nids = alc262_dac_nids,
11141 		.hp_nid = 0x02,
11142 		.dig_out_nid = ALC262_DIGOUT_NID,
11143 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11144 		.channel_mode = alc262_modes,
11145 		.input_mux = &alc262_capture_source,
11146 		.unsol_event = alc262_tyan_unsol_event,
11147 		.init_hook = alc262_tyan_automute,
11148 	},
11149 };
11150 
11151 static int patch_alc262(struct hda_codec *codec)
11152 {
11153 	struct alc_spec *spec;
11154 	int board_config;
11155 	int err;
11156 
11157 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11158 	if (spec == NULL)
11159 		return -ENOMEM;
11160 
11161 	codec->spec = spec;
11162 #if 0
11163 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11164 	 * under-run
11165 	 */
11166 	{
11167 	int tmp;
11168 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11169 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11170 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11171 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11172 	}
11173 #endif
11174 
11175 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11176 
11177 	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11178 						  alc262_models,
11179 						  alc262_cfg_tbl);
11180 
11181 	if (board_config < 0) {
11182 		printk(KERN_INFO "hda_codec: Unknown model for ALC262, "
11183 		       "trying auto-probe from BIOS...\n");
11184 		board_config = ALC262_AUTO;
11185 	}
11186 
11187 	if (board_config == ALC262_AUTO) {
11188 		/* automatic parse from the BIOS config */
11189 		err = alc262_parse_auto_config(codec);
11190 		if (err < 0) {
11191 			alc_free(codec);
11192 			return err;
11193 		} else if (!err) {
11194 			printk(KERN_INFO
11195 			       "hda_codec: Cannot set up configuration "
11196 			       "from BIOS.  Using base mode...\n");
11197 			board_config = ALC262_BASIC;
11198 		}
11199 	}
11200 
11201 	if (!spec->no_analog) {
11202 		err = snd_hda_attach_beep_device(codec, 0x1);
11203 		if (err < 0) {
11204 			alc_free(codec);
11205 			return err;
11206 		}
11207 	}
11208 
11209 	if (board_config != ALC262_AUTO)
11210 		setup_preset(spec, &alc262_presets[board_config]);
11211 
11212 	spec->stream_name_analog = "ALC262 Analog";
11213 	spec->stream_analog_playback = &alc262_pcm_analog_playback;
11214 	spec->stream_analog_capture = &alc262_pcm_analog_capture;
11215 
11216 	spec->stream_name_digital = "ALC262 Digital";
11217 	spec->stream_digital_playback = &alc262_pcm_digital_playback;
11218 	spec->stream_digital_capture = &alc262_pcm_digital_capture;
11219 
11220 	spec->capture_style = CAPT_MIX;
11221 	if (!spec->adc_nids && spec->input_mux) {
11222 		/* check whether NID 0x07 is valid */
11223 		unsigned int wcap = get_wcaps(codec, 0x07);
11224 
11225 		/* get type */
11226 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11227 		if (wcap != AC_WID_AUD_IN) {
11228 			spec->adc_nids = alc262_adc_nids_alt;
11229 			spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
11230 			spec->capsrc_nids = alc262_capsrc_nids_alt;
11231 		} else {
11232 			spec->adc_nids = alc262_adc_nids;
11233 			spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
11234 			spec->capsrc_nids = alc262_capsrc_nids;
11235 		}
11236 	}
11237 	if (!spec->cap_mixer && !spec->no_analog)
11238 		set_capture_mixer(spec);
11239 	if (!spec->no_analog)
11240 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11241 
11242 	spec->vmaster_nid = 0x0c;
11243 
11244 	codec->patch_ops = alc_patch_ops;
11245 	if (board_config == ALC262_AUTO)
11246 		spec->init_hook = alc262_auto_init;
11247 #ifdef CONFIG_SND_HDA_POWER_SAVE
11248 	if (!spec->loopback.amplist)
11249 		spec->loopback.amplist = alc262_loopbacks;
11250 #endif
11251 	codec->proc_widget_hook = print_realtek_coef;
11252 
11253 	return 0;
11254 }
11255 
11256 /*
11257  *  ALC268 channel source setting (2 channel)
11258  */
11259 #define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
11260 #define alc268_modes		alc260_modes
11261 
11262 static hda_nid_t alc268_dac_nids[2] = {
11263 	/* front, hp */
11264 	0x02, 0x03
11265 };
11266 
11267 static hda_nid_t alc268_adc_nids[2] = {
11268 	/* ADC0-1 */
11269 	0x08, 0x07
11270 };
11271 
11272 static hda_nid_t alc268_adc_nids_alt[1] = {
11273 	/* ADC0 */
11274 	0x08
11275 };
11276 
11277 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11278 
11279 static struct snd_kcontrol_new alc268_base_mixer[] = {
11280 	/* output mixer control */
11281 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11282 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11283 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11284 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11285 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11286 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11287 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11288 	{ }
11289 };
11290 
11291 /* bind Beep switches of both NID 0x0f and 0x10 */
11292 static struct hda_bind_ctls alc268_bind_beep_sw = {
11293 	.ops = &snd_hda_bind_sw,
11294 	.values = {
11295 		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11296 		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11297 		0
11298 	},
11299 };
11300 
11301 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11302 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11303 	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11304 	{ }
11305 };
11306 
11307 static struct hda_verb alc268_eapd_verbs[] = {
11308 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11309 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11310 	{ }
11311 };
11312 
11313 /* Toshiba specific */
11314 #define alc268_toshiba_automute	alc262_hippo_automute
11315 
11316 static struct hda_verb alc268_toshiba_verbs[] = {
11317 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11318 	{ } /* end */
11319 };
11320 
11321 static struct hda_input_mux alc268_acer_lc_capture_source = {
11322 	.num_items = 2,
11323 	.items = {
11324 		{ "i-Mic", 0x6 },
11325 		{ "E-Mic", 0x0 },
11326 	},
11327 };
11328 
11329 /* Acer specific */
11330 /* bind volumes of both NID 0x02 and 0x03 */
11331 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11332 	.ops = &snd_hda_bind_vol,
11333 	.values = {
11334 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11335 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11336 		0
11337 	},
11338 };
11339 
11340 /* mute/unmute internal speaker according to the hp jack and mute state */
11341 static void alc268_acer_automute(struct hda_codec *codec, int force)
11342 {
11343 	struct alc_spec *spec = codec->spec;
11344 	unsigned int mute;
11345 
11346 	if (force || !spec->sense_updated) {
11347 		unsigned int present;
11348 		present = snd_hda_codec_read(codec, 0x14, 0,
11349 				    	 AC_VERB_GET_PIN_SENSE, 0);
11350 		spec->jack_present = (present & 0x80000000) != 0;
11351 		spec->sense_updated = 1;
11352 	}
11353 	if (spec->jack_present)
11354 		mute = HDA_AMP_MUTE; /* mute internal speaker */
11355 	else /* unmute internal speaker if necessary */
11356 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11357 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11358 				 HDA_AMP_MUTE, mute);
11359 }
11360 
11361 
11362 /* bind hp and internal speaker mute (with plug check) */
11363 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11364 				     struct snd_ctl_elem_value *ucontrol)
11365 {
11366 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11367 	long *valp = ucontrol->value.integer.value;
11368 	int change;
11369 
11370 	change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11371 					  HDA_AMP_MUTE,
11372 					  valp[0] ? 0 : HDA_AMP_MUTE);
11373 	change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11374 					   HDA_AMP_MUTE,
11375 					   valp[1] ? 0 : HDA_AMP_MUTE);
11376 	if (change)
11377 		alc268_acer_automute(codec, 0);
11378 	return change;
11379 }
11380 
11381 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11382 	/* output mixer control */
11383 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11384 	{
11385 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11386 		.name = "Master Playback Switch",
11387 		.info = snd_hda_mixer_amp_switch_info,
11388 		.get = snd_hda_mixer_amp_switch_get,
11389 		.put = alc268_acer_master_sw_put,
11390 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11391 	},
11392 	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11393 	{ }
11394 };
11395 
11396 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11397 	/* output mixer control */
11398 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11399 	{
11400 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11401 		.name = "Master Playback Switch",
11402 		.info = snd_hda_mixer_amp_switch_info,
11403 		.get = snd_hda_mixer_amp_switch_get,
11404 		.put = alc268_acer_master_sw_put,
11405 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11406 	},
11407 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11408 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11409 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11410 	{ }
11411 };
11412 
11413 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11414 	/* output mixer control */
11415 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11416 	{
11417 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11418 		.name = "Master Playback Switch",
11419 		.info = snd_hda_mixer_amp_switch_info,
11420 		.get = snd_hda_mixer_amp_switch_get,
11421 		.put = alc268_acer_master_sw_put,
11422 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11423 	},
11424 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11425 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11426 	{ }
11427 };
11428 
11429 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11430 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11431 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11432 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11433 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11434 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11435 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11436 	{ }
11437 };
11438 
11439 static struct hda_verb alc268_acer_verbs[] = {
11440 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11441 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11442 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11443 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11444 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11445 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11446 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11447 	{ }
11448 };
11449 
11450 /* unsolicited event for HP jack sensing */
11451 static void alc268_toshiba_unsol_event(struct hda_codec *codec,
11452 				       unsigned int res)
11453 {
11454 	if ((res >> 26) != ALC880_HP_EVENT)
11455 		return;
11456 	alc268_toshiba_automute(codec);
11457 }
11458 
11459 static void alc268_acer_unsol_event(struct hda_codec *codec,
11460 				       unsigned int res)
11461 {
11462 	if ((res >> 26) != ALC880_HP_EVENT)
11463 		return;
11464 	alc268_acer_automute(codec, 1);
11465 }
11466 
11467 static void alc268_acer_init_hook(struct hda_codec *codec)
11468 {
11469 	alc268_acer_automute(codec, 1);
11470 }
11471 
11472 /* toggle speaker-output according to the hp-jack state */
11473 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11474 {
11475 	unsigned int present;
11476 	unsigned char bits;
11477 
11478 	present = snd_hda_codec_read(codec, 0x15, 0,
11479 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11480 	bits = present ? AMP_IN_MUTE(0) : 0;
11481 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11482 				AMP_IN_MUTE(0), bits);
11483 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11484 				AMP_IN_MUTE(0), bits);
11485 }
11486 
11487 
11488 static void alc268_acer_mic_automute(struct hda_codec *codec)
11489 {
11490 	unsigned int present;
11491 
11492 	present = snd_hda_codec_read(codec, 0x18, 0,
11493 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11494 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11495 			    present ? 0x0 : 0x6);
11496 }
11497 
11498 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11499 				    unsigned int res)
11500 {
11501 	if ((res >> 26) == ALC880_HP_EVENT)
11502 		alc268_aspire_one_speaker_automute(codec);
11503 	if ((res >> 26) == ALC880_MIC_EVENT)
11504 		alc268_acer_mic_automute(codec);
11505 }
11506 
11507 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11508 {
11509 	alc268_aspire_one_speaker_automute(codec);
11510 	alc268_acer_mic_automute(codec);
11511 }
11512 
11513 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11514 	/* output mixer control */
11515 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11516 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11517 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11518 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11519 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11520 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11521 	{ }
11522 };
11523 
11524 static struct hda_verb alc268_dell_verbs[] = {
11525 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11526 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11527 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11528 	{ }
11529 };
11530 
11531 /* mute/unmute internal speaker according to the hp jack and mute state */
11532 static void alc268_dell_automute(struct hda_codec *codec)
11533 {
11534 	unsigned int present;
11535 	unsigned int mute;
11536 
11537 	present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0);
11538 	if (present & 0x80000000)
11539 		mute = HDA_AMP_MUTE;
11540 	else
11541 		mute = snd_hda_codec_amp_read(codec, 0x15, 0, HDA_OUTPUT, 0);
11542 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11543 				 HDA_AMP_MUTE, mute);
11544 }
11545 
11546 static void alc268_dell_unsol_event(struct hda_codec *codec,
11547 				    unsigned int res)
11548 {
11549 	if ((res >> 26) != ALC880_HP_EVENT)
11550 		return;
11551 	alc268_dell_automute(codec);
11552 }
11553 
11554 #define alc268_dell_init_hook	alc268_dell_automute
11555 
11556 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11557 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11558 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11559 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11560 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11561 	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11562 	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11563 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11564 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11565 	{ }
11566 };
11567 
11568 static struct hda_verb alc267_quanta_il1_verbs[] = {
11569 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11570 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11571 	{ }
11572 };
11573 
11574 static void alc267_quanta_il1_hp_automute(struct hda_codec *codec)
11575 {
11576 	unsigned int present;
11577 
11578 	present = snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_PIN_SENSE, 0)
11579 		& AC_PINSENSE_PRESENCE;
11580 	snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
11581 			    present ? 0 : PIN_OUT);
11582 }
11583 
11584 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11585 {
11586 	unsigned int present;
11587 
11588 	present = snd_hda_codec_read(codec, 0x18, 0,
11589 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11590 	snd_hda_codec_write(codec, 0x23, 0,
11591 			    AC_VERB_SET_CONNECT_SEL,
11592 			    present ? 0x00 : 0x01);
11593 }
11594 
11595 static void alc267_quanta_il1_automute(struct hda_codec *codec)
11596 {
11597 	alc267_quanta_il1_hp_automute(codec);
11598 	alc267_quanta_il1_mic_automute(codec);
11599 }
11600 
11601 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11602 					   unsigned int res)
11603 {
11604 	switch (res >> 26) {
11605 	case ALC880_HP_EVENT:
11606 		alc267_quanta_il1_hp_automute(codec);
11607 		break;
11608 	case ALC880_MIC_EVENT:
11609 		alc267_quanta_il1_mic_automute(codec);
11610 		break;
11611 	}
11612 }
11613 
11614 /*
11615  * generic initialization of ADC, input mixers and output mixers
11616  */
11617 static struct hda_verb alc268_base_init_verbs[] = {
11618 	/* Unmute DAC0-1 and set vol = 0 */
11619 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11620 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11621 
11622 	/*
11623 	 * Set up output mixers (0x0c - 0x0e)
11624 	 */
11625 	/* set vol=0 to output mixers */
11626 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11627         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11628 
11629 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11630 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11631 
11632 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11633 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11634 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11635 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11636 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11637 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11638 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11639 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11640 
11641 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11642 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11643 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11644 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11645 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11646 
11647 	/* set PCBEEP vol = 0, mute connections */
11648 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11649 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11650 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11651 
11652 	/* Unmute Selector 23h,24h and set the default input to mic-in */
11653 
11654 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11655 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11656 	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11657 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11658 
11659 	{ }
11660 };
11661 
11662 /*
11663  * generic initialization of ADC, input mixers and output mixers
11664  */
11665 static struct hda_verb alc268_volume_init_verbs[] = {
11666 	/* set output DAC */
11667 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11668 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11669 
11670 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11671 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11672 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11673 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11674 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11675 
11676 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11677 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11678 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11679 
11680 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11681 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11682 
11683 	/* set PCBEEP vol = 0, mute connections */
11684 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11685 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11686 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11687 
11688 	{ }
11689 };
11690 
11691 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11692 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11693 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11694 	{
11695 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11696 		/* The multiple "Capture Source" controls confuse alsamixer
11697 		 * So call somewhat different..
11698 		 */
11699 		/* .name = "Capture Source", */
11700 		.name = "Input Source",
11701 		.count = 1,
11702 		.info = alc_mux_enum_info,
11703 		.get = alc_mux_enum_get,
11704 		.put = alc_mux_enum_put,
11705 	},
11706 	{ } /* end */
11707 };
11708 
11709 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11710 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11711 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11712 	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11713 	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11714 	{
11715 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11716 		/* The multiple "Capture Source" controls confuse alsamixer
11717 		 * So call somewhat different..
11718 		 */
11719 		/* .name = "Capture Source", */
11720 		.name = "Input Source",
11721 		.count = 2,
11722 		.info = alc_mux_enum_info,
11723 		.get = alc_mux_enum_get,
11724 		.put = alc_mux_enum_put,
11725 	},
11726 	{ } /* end */
11727 };
11728 
11729 static struct hda_input_mux alc268_capture_source = {
11730 	.num_items = 4,
11731 	.items = {
11732 		{ "Mic", 0x0 },
11733 		{ "Front Mic", 0x1 },
11734 		{ "Line", 0x2 },
11735 		{ "CD", 0x3 },
11736 	},
11737 };
11738 
11739 static struct hda_input_mux alc268_acer_capture_source = {
11740 	.num_items = 3,
11741 	.items = {
11742 		{ "Mic", 0x0 },
11743 		{ "Internal Mic", 0x1 },
11744 		{ "Line", 0x2 },
11745 	},
11746 };
11747 
11748 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11749 	.num_items = 3,
11750 	.items = {
11751 		{ "Mic", 0x0 },
11752 		{ "Internal Mic", 0x6 },
11753 		{ "Line", 0x2 },
11754 	},
11755 };
11756 
11757 #ifdef CONFIG_SND_DEBUG
11758 static struct snd_kcontrol_new alc268_test_mixer[] = {
11759 	/* Volume widgets */
11760 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11761 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11762 	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11763 	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11764 	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11765 	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11766 	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11767 	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11768 	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11769 	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11770 	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11771 	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11772 	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11773 	/* The below appears problematic on some hardwares */
11774 	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11775 	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11776 	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11777 	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11778 	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11779 
11780 	/* Modes for retasking pin widgets */
11781 	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11782 	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11783 	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11784 	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11785 
11786 	/* Controls for GPIO pins, assuming they are configured as outputs */
11787 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11788 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11789 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11790 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11791 
11792 	/* Switches to allow the digital SPDIF output pin to be enabled.
11793 	 * The ALC268 does not have an SPDIF input.
11794 	 */
11795 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11796 
11797 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
11798 	 * this output to turn on an external amplifier.
11799 	 */
11800 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11801 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11802 
11803 	{ } /* end */
11804 };
11805 #endif
11806 
11807 /* create input playback/capture controls for the given pin */
11808 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11809 				    const char *ctlname, int idx)
11810 {
11811 	char name[32];
11812 	int err;
11813 
11814 	sprintf(name, "%s Playback Volume", ctlname);
11815 	if (nid == 0x14) {
11816 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11817 				  HDA_COMPOSE_AMP_VAL(0x02, 3, idx,
11818 						      HDA_OUTPUT));
11819 		if (err < 0)
11820 			return err;
11821 	} else if (nid == 0x15) {
11822 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11823 				  HDA_COMPOSE_AMP_VAL(0x03, 3, idx,
11824 						      HDA_OUTPUT));
11825 		if (err < 0)
11826 			return err;
11827 	} else
11828 		return -1;
11829 	sprintf(name, "%s Playback Switch", ctlname);
11830 	err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11831 			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11832 	if (err < 0)
11833 		return err;
11834 	return 0;
11835 }
11836 
11837 /* add playback controls from the parsed DAC table */
11838 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11839 					     const struct auto_pin_cfg *cfg)
11840 {
11841 	hda_nid_t nid;
11842 	int err;
11843 
11844 	spec->multiout.num_dacs = 2;	/* only use one dac */
11845 	spec->multiout.dac_nids = spec->private_dac_nids;
11846 	spec->multiout.dac_nids[0] = 2;
11847 	spec->multiout.dac_nids[1] = 3;
11848 
11849 	nid = cfg->line_out_pins[0];
11850 	if (nid)
11851 		alc268_new_analog_output(spec, nid, "Front", 0);
11852 
11853 	nid = cfg->speaker_pins[0];
11854 	if (nid == 0x1d) {
11855 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
11856 				  "Speaker Playback Volume",
11857 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11858 		if (err < 0)
11859 			return err;
11860 	}
11861 	nid = cfg->hp_pins[0];
11862 	if (nid)
11863 		alc268_new_analog_output(spec, nid, "Headphone", 0);
11864 
11865 	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11866 	if (nid == 0x16) {
11867 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11868 				  "Mono Playback Switch",
11869 				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_INPUT));
11870 		if (err < 0)
11871 			return err;
11872 	}
11873 	return 0;
11874 }
11875 
11876 /* create playback/capture controls for input pins */
11877 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11878 						const struct auto_pin_cfg *cfg)
11879 {
11880 	struct hda_input_mux *imux = &spec->private_imux[0];
11881 	int i, idx1;
11882 
11883 	for (i = 0; i < AUTO_PIN_LAST; i++) {
11884 		switch(cfg->input_pins[i]) {
11885 		case 0x18:
11886 			idx1 = 0;	/* Mic 1 */
11887 			break;
11888 		case 0x19:
11889 			idx1 = 1;	/* Mic 2 */
11890 			break;
11891 		case 0x1a:
11892 			idx1 = 2;	/* Line In */
11893 			break;
11894 		case 0x1c:
11895 			idx1 = 3;	/* CD */
11896 			break;
11897 		case 0x12:
11898 		case 0x13:
11899 			idx1 = 6;	/* digital mics */
11900 			break;
11901 		default:
11902 			continue;
11903 		}
11904 		imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11905 		imux->items[imux->num_items].index = idx1;
11906 		imux->num_items++;
11907 	}
11908 	return 0;
11909 }
11910 
11911 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11912 {
11913 	struct alc_spec *spec = codec->spec;
11914 	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11915 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11916 	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11917 	unsigned int	dac_vol1, dac_vol2;
11918 
11919 	if (speaker_nid) {
11920 		snd_hda_codec_write(codec, speaker_nid, 0,
11921 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11922 		snd_hda_codec_write(codec, 0x0f, 0,
11923 				    AC_VERB_SET_AMP_GAIN_MUTE,
11924 				    AMP_IN_UNMUTE(1));
11925 		snd_hda_codec_write(codec, 0x10, 0,
11926 				    AC_VERB_SET_AMP_GAIN_MUTE,
11927 				    AMP_IN_UNMUTE(1));
11928 	} else {
11929 		snd_hda_codec_write(codec, 0x0f, 0,
11930 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11931 		snd_hda_codec_write(codec, 0x10, 0,
11932 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11933 	}
11934 
11935 	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
11936 	if (line_nid == 0x14)
11937 		dac_vol2 = AMP_OUT_ZERO;
11938 	else if (line_nid == 0x15)
11939 		dac_vol1 = AMP_OUT_ZERO;
11940 	if (hp_nid == 0x14)
11941 		dac_vol2 = AMP_OUT_ZERO;
11942 	else if (hp_nid == 0x15)
11943 		dac_vol1 = AMP_OUT_ZERO;
11944 	if (line_nid != 0x16 || hp_nid != 0x16 ||
11945 	    spec->autocfg.line_out_pins[1] != 0x16 ||
11946 	    spec->autocfg.line_out_pins[2] != 0x16)
11947 		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11948 
11949 	snd_hda_codec_write(codec, 0x02, 0,
11950 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11951 	snd_hda_codec_write(codec, 0x03, 0,
11952 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11953 }
11954 
11955 /* pcm configuration: identiacal with ALC880 */
11956 #define alc268_pcm_analog_playback	alc880_pcm_analog_playback
11957 #define alc268_pcm_analog_capture	alc880_pcm_analog_capture
11958 #define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
11959 #define alc268_pcm_digital_playback	alc880_pcm_digital_playback
11960 
11961 /*
11962  * BIOS auto configuration
11963  */
11964 static int alc268_parse_auto_config(struct hda_codec *codec)
11965 {
11966 	struct alc_spec *spec = codec->spec;
11967 	int err;
11968 	static hda_nid_t alc268_ignore[] = { 0 };
11969 
11970 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11971 					   alc268_ignore);
11972 	if (err < 0)
11973 		return err;
11974 	if (!spec->autocfg.line_outs) {
11975 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11976 			spec->multiout.max_channels = 2;
11977 			spec->no_analog = 1;
11978 			goto dig_only;
11979 		}
11980 		return 0; /* can't find valid BIOS pin config */
11981 	}
11982 	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
11983 	if (err < 0)
11984 		return err;
11985 	err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
11986 	if (err < 0)
11987 		return err;
11988 
11989 	spec->multiout.max_channels = 2;
11990 
11991  dig_only:
11992 	/* digital only support output */
11993 	if (spec->autocfg.dig_outs) {
11994 		spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
11995 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
11996 	}
11997 	if (spec->kctls.list)
11998 		add_mixer(spec, spec->kctls.list);
11999 
12000 	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12001 		add_mixer(spec, alc268_beep_mixer);
12002 
12003 	add_verb(spec, alc268_volume_init_verbs);
12004 	spec->num_mux_defs = 1;
12005 	spec->input_mux = &spec->private_imux[0];
12006 
12007 	err = alc_auto_add_mic_boost(codec);
12008 	if (err < 0)
12009 		return err;
12010 
12011 	return 1;
12012 }
12013 
12014 #define alc268_auto_init_multi_out	alc882_auto_init_multi_out
12015 #define alc268_auto_init_hp_out		alc882_auto_init_hp_out
12016 #define alc268_auto_init_analog_input	alc882_auto_init_analog_input
12017 
12018 /* init callback for auto-configuration model -- overriding the default init */
12019 static void alc268_auto_init(struct hda_codec *codec)
12020 {
12021 	struct alc_spec *spec = codec->spec;
12022 	alc268_auto_init_multi_out(codec);
12023 	alc268_auto_init_hp_out(codec);
12024 	alc268_auto_init_mono_speaker_out(codec);
12025 	alc268_auto_init_analog_input(codec);
12026 	if (spec->unsol_event)
12027 		alc_inithook(codec);
12028 }
12029 
12030 /*
12031  * configuration and preset
12032  */
12033 static const char *alc268_models[ALC268_MODEL_LAST] = {
12034 	[ALC267_QUANTA_IL1]	= "quanta-il1",
12035 	[ALC268_3ST]		= "3stack",
12036 	[ALC268_TOSHIBA]	= "toshiba",
12037 	[ALC268_ACER]		= "acer",
12038 	[ALC268_ACER_DMIC]	= "acer-dmic",
12039 	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
12040 	[ALC268_DELL]		= "dell",
12041 	[ALC268_ZEPTO]		= "zepto",
12042 #ifdef CONFIG_SND_DEBUG
12043 	[ALC268_TEST]		= "test",
12044 #endif
12045 	[ALC268_AUTO]		= "auto",
12046 };
12047 
12048 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12049 	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12050 	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12051 	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12052 	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12053 	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12054 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12055 						ALC268_ACER_ASPIRE_ONE),
12056 	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12057 	SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12058 	SND_PCI_QUIRK(0x103c, 0x30cc, "TOSHIBA", ALC268_TOSHIBA),
12059 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12060 	SND_PCI_QUIRK(0x1179, 0xff10, "TOSHIBA A205", ALC268_TOSHIBA),
12061 	SND_PCI_QUIRK(0x1179, 0xff50, "TOSHIBA A305", ALC268_TOSHIBA),
12062 	SND_PCI_QUIRK(0x1179, 0xff64, "TOSHIBA L305", ALC268_TOSHIBA),
12063 	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12064 	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12065 	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12066 	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12067 	{}
12068 };
12069 
12070 static struct alc_config_preset alc268_presets[] = {
12071 	[ALC267_QUANTA_IL1] = {
12072 		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12073 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12074 				alc267_quanta_il1_verbs },
12075 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12076 		.dac_nids = alc268_dac_nids,
12077 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12078 		.adc_nids = alc268_adc_nids_alt,
12079 		.hp_nid = 0x03,
12080 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12081 		.channel_mode = alc268_modes,
12082 		.input_mux = &alc268_capture_source,
12083 		.unsol_event = alc267_quanta_il1_unsol_event,
12084 		.init_hook = alc267_quanta_il1_automute,
12085 	},
12086 	[ALC268_3ST] = {
12087 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12088 			    alc268_beep_mixer },
12089 		.init_verbs = { alc268_base_init_verbs },
12090 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12091 		.dac_nids = alc268_dac_nids,
12092                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12093                 .adc_nids = alc268_adc_nids_alt,
12094 		.capsrc_nids = alc268_capsrc_nids,
12095 		.hp_nid = 0x03,
12096 		.dig_out_nid = ALC268_DIGOUT_NID,
12097 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12098 		.channel_mode = alc268_modes,
12099 		.input_mux = &alc268_capture_source,
12100 	},
12101 	[ALC268_TOSHIBA] = {
12102 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12103 			    alc268_beep_mixer },
12104 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12105 				alc268_toshiba_verbs },
12106 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12107 		.dac_nids = alc268_dac_nids,
12108 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12109 		.adc_nids = alc268_adc_nids_alt,
12110 		.capsrc_nids = alc268_capsrc_nids,
12111 		.hp_nid = 0x03,
12112 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12113 		.channel_mode = alc268_modes,
12114 		.input_mux = &alc268_capture_source,
12115 		.unsol_event = alc268_toshiba_unsol_event,
12116 		.init_hook = alc268_toshiba_automute,
12117 	},
12118 	[ALC268_ACER] = {
12119 		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12120 			    alc268_beep_mixer },
12121 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12122 				alc268_acer_verbs },
12123 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12124 		.dac_nids = alc268_dac_nids,
12125 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12126 		.adc_nids = alc268_adc_nids_alt,
12127 		.capsrc_nids = alc268_capsrc_nids,
12128 		.hp_nid = 0x02,
12129 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12130 		.channel_mode = alc268_modes,
12131 		.input_mux = &alc268_acer_capture_source,
12132 		.unsol_event = alc268_acer_unsol_event,
12133 		.init_hook = alc268_acer_init_hook,
12134 	},
12135 	[ALC268_ACER_DMIC] = {
12136 		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12137 			    alc268_beep_mixer },
12138 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12139 				alc268_acer_verbs },
12140 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12141 		.dac_nids = alc268_dac_nids,
12142 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12143 		.adc_nids = alc268_adc_nids_alt,
12144 		.capsrc_nids = alc268_capsrc_nids,
12145 		.hp_nid = 0x02,
12146 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12147 		.channel_mode = alc268_modes,
12148 		.input_mux = &alc268_acer_dmic_capture_source,
12149 		.unsol_event = alc268_acer_unsol_event,
12150 		.init_hook = alc268_acer_init_hook,
12151 	},
12152 	[ALC268_ACER_ASPIRE_ONE] = {
12153 		.mixers = { alc268_acer_aspire_one_mixer,
12154 			    alc268_beep_mixer,
12155 			    alc268_capture_alt_mixer },
12156 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12157 				alc268_acer_aspire_one_verbs },
12158 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12159 		.dac_nids = alc268_dac_nids,
12160 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12161 		.adc_nids = alc268_adc_nids_alt,
12162 		.capsrc_nids = alc268_capsrc_nids,
12163 		.hp_nid = 0x03,
12164 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12165 		.channel_mode = alc268_modes,
12166 		.input_mux = &alc268_acer_lc_capture_source,
12167 		.unsol_event = alc268_acer_lc_unsol_event,
12168 		.init_hook = alc268_acer_lc_init_hook,
12169 	},
12170 	[ALC268_DELL] = {
12171 		.mixers = { alc268_dell_mixer, alc268_beep_mixer },
12172 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12173 				alc268_dell_verbs },
12174 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12175 		.dac_nids = alc268_dac_nids,
12176 		.hp_nid = 0x02,
12177 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12178 		.channel_mode = alc268_modes,
12179 		.unsol_event = alc268_dell_unsol_event,
12180 		.init_hook = alc268_dell_init_hook,
12181 		.input_mux = &alc268_capture_source,
12182 	},
12183 	[ALC268_ZEPTO] = {
12184 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12185 			    alc268_beep_mixer },
12186 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12187 				alc268_toshiba_verbs },
12188 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12189 		.dac_nids = alc268_dac_nids,
12190 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12191 		.adc_nids = alc268_adc_nids_alt,
12192 		.capsrc_nids = alc268_capsrc_nids,
12193 		.hp_nid = 0x03,
12194 		.dig_out_nid = ALC268_DIGOUT_NID,
12195 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12196 		.channel_mode = alc268_modes,
12197 		.input_mux = &alc268_capture_source,
12198 		.unsol_event = alc268_toshiba_unsol_event,
12199 		.init_hook = alc268_toshiba_automute
12200 	},
12201 #ifdef CONFIG_SND_DEBUG
12202 	[ALC268_TEST] = {
12203 		.mixers = { alc268_test_mixer, alc268_capture_mixer },
12204 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12205 				alc268_volume_init_verbs },
12206 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12207 		.dac_nids = alc268_dac_nids,
12208 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12209 		.adc_nids = alc268_adc_nids_alt,
12210 		.capsrc_nids = alc268_capsrc_nids,
12211 		.hp_nid = 0x03,
12212 		.dig_out_nid = ALC268_DIGOUT_NID,
12213 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12214 		.channel_mode = alc268_modes,
12215 		.input_mux = &alc268_capture_source,
12216 	},
12217 #endif
12218 };
12219 
12220 static int patch_alc268(struct hda_codec *codec)
12221 {
12222 	struct alc_spec *spec;
12223 	int board_config;
12224 	int i, has_beep, err;
12225 
12226 	spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12227 	if (spec == NULL)
12228 		return -ENOMEM;
12229 
12230 	codec->spec = spec;
12231 
12232 	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12233 						  alc268_models,
12234 						  alc268_cfg_tbl);
12235 
12236 	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12237 		printk(KERN_INFO "hda_codec: Unknown model for ALC268, "
12238 		       "trying auto-probe from BIOS...\n");
12239 		board_config = ALC268_AUTO;
12240 	}
12241 
12242 	if (board_config == ALC268_AUTO) {
12243 		/* automatic parse from the BIOS config */
12244 		err = alc268_parse_auto_config(codec);
12245 		if (err < 0) {
12246 			alc_free(codec);
12247 			return err;
12248 		} else if (!err) {
12249 			printk(KERN_INFO
12250 			       "hda_codec: Cannot set up configuration "
12251 			       "from BIOS.  Using base mode...\n");
12252 			board_config = ALC268_3ST;
12253 		}
12254 	}
12255 
12256 	if (board_config != ALC268_AUTO)
12257 		setup_preset(spec, &alc268_presets[board_config]);
12258 
12259 	if (codec->vendor_id == 0x10ec0267) {
12260 		spec->stream_name_analog = "ALC267 Analog";
12261 		spec->stream_name_digital = "ALC267 Digital";
12262 	} else {
12263 		spec->stream_name_analog = "ALC268 Analog";
12264 		spec->stream_name_digital = "ALC268 Digital";
12265 	}
12266 
12267 	spec->stream_analog_playback = &alc268_pcm_analog_playback;
12268 	spec->stream_analog_capture = &alc268_pcm_analog_capture;
12269 	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12270 
12271 	spec->stream_digital_playback = &alc268_pcm_digital_playback;
12272 
12273 	has_beep = 0;
12274 	for (i = 0; i < spec->num_mixers; i++) {
12275 		if (spec->mixers[i] == alc268_beep_mixer) {
12276 			has_beep = 1;
12277 			break;
12278 		}
12279 	}
12280 
12281 	if (has_beep) {
12282 		err = snd_hda_attach_beep_device(codec, 0x1);
12283 		if (err < 0) {
12284 			alc_free(codec);
12285 			return err;
12286 		}
12287 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12288 			/* override the amp caps for beep generator */
12289 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12290 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12291 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12292 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12293 					  (0 << AC_AMPCAP_MUTE_SHIFT));
12294 	}
12295 
12296 	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12297 		/* check whether NID 0x07 is valid */
12298 		unsigned int wcap = get_wcaps(codec, 0x07);
12299 		int i;
12300 
12301 		/* get type */
12302 		wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12303 		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12304 			spec->adc_nids = alc268_adc_nids_alt;
12305 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12306 			add_mixer(spec, alc268_capture_alt_mixer);
12307 		} else {
12308 			spec->adc_nids = alc268_adc_nids;
12309 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12310 			add_mixer(spec, alc268_capture_mixer);
12311 		}
12312 		spec->capsrc_nids = alc268_capsrc_nids;
12313 		/* set default input source */
12314 		for (i = 0; i < spec->num_adc_nids; i++)
12315 			snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12316 				0, AC_VERB_SET_CONNECT_SEL,
12317 				spec->input_mux->items[0].index);
12318 	}
12319 
12320 	spec->vmaster_nid = 0x02;
12321 
12322 	codec->patch_ops = alc_patch_ops;
12323 	if (board_config == ALC268_AUTO)
12324 		spec->init_hook = alc268_auto_init;
12325 
12326 	codec->proc_widget_hook = print_realtek_coef;
12327 
12328 	return 0;
12329 }
12330 
12331 /*
12332  *  ALC269 channel source setting (2 channel)
12333  */
12334 #define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
12335 
12336 #define alc269_dac_nids		alc260_dac_nids
12337 
12338 static hda_nid_t alc269_adc_nids[1] = {
12339 	/* ADC1 */
12340 	0x08,
12341 };
12342 
12343 static hda_nid_t alc269_capsrc_nids[1] = {
12344 	0x23,
12345 };
12346 
12347 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12348  *       not a mux!
12349  */
12350 
12351 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12352 	.num_items = 2,
12353 	.items = {
12354 		{ "i-Mic", 0x5 },
12355 		{ "e-Mic", 0x0 },
12356 	},
12357 };
12358 
12359 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12360 	.num_items = 2,
12361 	.items = {
12362 		{ "i-Mic", 0x1 },
12363 		{ "e-Mic", 0x0 },
12364 	},
12365 };
12366 
12367 #define alc269_modes		alc260_modes
12368 #define alc269_capture_source	alc880_lg_lw_capture_source
12369 
12370 static struct snd_kcontrol_new alc269_base_mixer[] = {
12371 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12372 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12373 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12374 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12375 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12376 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12377 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12378 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12379 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12380 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12381 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12382 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12383 	{ } /* end */
12384 };
12385 
12386 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12387 	/* output mixer control */
12388 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12389 	{
12390 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12391 		.name = "Master Playback Switch",
12392 		.info = snd_hda_mixer_amp_switch_info,
12393 		.get = snd_hda_mixer_amp_switch_get,
12394 		.put = alc268_acer_master_sw_put,
12395 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12396 	},
12397 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12398 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12399 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12400 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12401 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12402 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12403 	{ }
12404 };
12405 
12406 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12407 	/* output mixer control */
12408 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12409 	{
12410 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12411 		.name = "Master Playback Switch",
12412 		.info = snd_hda_mixer_amp_switch_info,
12413 		.get = snd_hda_mixer_amp_switch_get,
12414 		.put = alc268_acer_master_sw_put,
12415 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12416 	},
12417 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12418 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12419 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12420 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12421 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12422 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12423 	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12424 	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12425 	HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12426 	{ }
12427 };
12428 
12429 /* bind volumes of both NID 0x0c and 0x0d */
12430 static struct hda_bind_ctls alc269_epc_bind_vol = {
12431 	.ops = &snd_hda_bind_vol,
12432 	.values = {
12433 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12434 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12435 		0
12436 	},
12437 };
12438 
12439 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12440 	HDA_CODEC_MUTE("iSpeaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12441 	HDA_BIND_VOL("LineOut Playback Volume", &alc269_epc_bind_vol),
12442 	HDA_CODEC_MUTE("LineOut Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12443 	{ } /* end */
12444 };
12445 
12446 /* capture mixer elements */
12447 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12448 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12449 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12450 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12451 	{ } /* end */
12452 };
12453 
12454 /* FSC amilo */
12455 static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
12456 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12457 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12458 	HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
12459 	{ } /* end */
12460 };
12461 
12462 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12463 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12464 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12465 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12466 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12467 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12468 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12469 	{ }
12470 };
12471 
12472 static struct hda_verb alc269_lifebook_verbs[] = {
12473 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12474 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12475 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12476 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12477 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12478 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12479 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12480 	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12481 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12482 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12483 	{ }
12484 };
12485 
12486 /* toggle speaker-output according to the hp-jack state */
12487 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12488 {
12489 	unsigned int present;
12490 	unsigned char bits;
12491 
12492 	present = snd_hda_codec_read(codec, 0x15, 0,
12493 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12494 	bits = present ? AMP_IN_MUTE(0) : 0;
12495 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12496 			AMP_IN_MUTE(0), bits);
12497 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12498 			AMP_IN_MUTE(0), bits);
12499 
12500 	snd_hda_codec_write(codec, 0x20, 0,
12501 			AC_VERB_SET_COEF_INDEX, 0x0c);
12502 	snd_hda_codec_write(codec, 0x20, 0,
12503 			AC_VERB_SET_PROC_COEF, 0x680);
12504 
12505 	snd_hda_codec_write(codec, 0x20, 0,
12506 			AC_VERB_SET_COEF_INDEX, 0x0c);
12507 	snd_hda_codec_write(codec, 0x20, 0,
12508 			AC_VERB_SET_PROC_COEF, 0x480);
12509 }
12510 
12511 /* toggle speaker-output according to the hp-jacks state */
12512 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12513 {
12514 	unsigned int present;
12515 	unsigned char bits;
12516 
12517 	/* Check laptop headphone socket */
12518 	present = snd_hda_codec_read(codec, 0x15, 0,
12519 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12520 
12521 	/* Check port replicator headphone socket */
12522 	present |= snd_hda_codec_read(codec, 0x1a, 0,
12523 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12524 
12525 	bits = present ? AMP_IN_MUTE(0) : 0;
12526 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12527 			AMP_IN_MUTE(0), bits);
12528 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12529 			AMP_IN_MUTE(0), bits);
12530 
12531 	snd_hda_codec_write(codec, 0x20, 0,
12532 			AC_VERB_SET_COEF_INDEX, 0x0c);
12533 	snd_hda_codec_write(codec, 0x20, 0,
12534 			AC_VERB_SET_PROC_COEF, 0x680);
12535 
12536 	snd_hda_codec_write(codec, 0x20, 0,
12537 			AC_VERB_SET_COEF_INDEX, 0x0c);
12538 	snd_hda_codec_write(codec, 0x20, 0,
12539 			AC_VERB_SET_PROC_COEF, 0x480);
12540 }
12541 
12542 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12543 {
12544 	unsigned int present;
12545 
12546 	present = snd_hda_codec_read(codec, 0x18, 0,
12547 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12548 	snd_hda_codec_write(codec, 0x23, 0,
12549 			    AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12550 }
12551 
12552 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12553 {
12554 	unsigned int present_laptop;
12555 	unsigned int present_dock;
12556 
12557 	present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12558 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12559 
12560 	present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12561 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12562 
12563 	/* Laptop mic port overrides dock mic port, design decision */
12564 	if (present_dock)
12565 		snd_hda_codec_write(codec, 0x23, 0,
12566 				AC_VERB_SET_CONNECT_SEL, 0x3);
12567 	if (present_laptop)
12568 		snd_hda_codec_write(codec, 0x23, 0,
12569 				AC_VERB_SET_CONNECT_SEL, 0x0);
12570 	if (!present_dock && !present_laptop)
12571 		snd_hda_codec_write(codec, 0x23, 0,
12572 				AC_VERB_SET_CONNECT_SEL, 0x1);
12573 }
12574 
12575 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12576 				    unsigned int res)
12577 {
12578 	if ((res >> 26) == ALC880_HP_EVENT)
12579 		alc269_quanta_fl1_speaker_automute(codec);
12580 	if ((res >> 26) == ALC880_MIC_EVENT)
12581 		alc269_quanta_fl1_mic_automute(codec);
12582 }
12583 
12584 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12585 					unsigned int res)
12586 {
12587 	if ((res >> 26) == ALC880_HP_EVENT)
12588 		alc269_lifebook_speaker_automute(codec);
12589 	if ((res >> 26) == ALC880_MIC_EVENT)
12590 		alc269_lifebook_mic_autoswitch(codec);
12591 }
12592 
12593 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12594 {
12595 	alc269_quanta_fl1_speaker_automute(codec);
12596 	alc269_quanta_fl1_mic_automute(codec);
12597 }
12598 
12599 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12600 {
12601 	alc269_lifebook_speaker_automute(codec);
12602 	alc269_lifebook_mic_autoswitch(codec);
12603 }
12604 
12605 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12606 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12607 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12608 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12609 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12610 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12611 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12612 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12613 	{}
12614 };
12615 
12616 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12617 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12618 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12619 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12620 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12621 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12622 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12623 	{}
12624 };
12625 
12626 /* toggle speaker-output according to the hp-jack state */
12627 static void alc269_speaker_automute(struct hda_codec *codec)
12628 {
12629 	unsigned int present;
12630 	unsigned char bits;
12631 
12632 	present = snd_hda_codec_read(codec, 0x15, 0,
12633 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12634 	bits = present ? AMP_IN_MUTE(0) : 0;
12635 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12636 				AMP_IN_MUTE(0), bits);
12637 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12638 				AMP_IN_MUTE(0), bits);
12639 }
12640 
12641 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12642 {
12643 	unsigned int present;
12644 
12645 	present = snd_hda_codec_read(codec, 0x18, 0,
12646 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12647 	snd_hda_codec_write(codec, 0x23, 0,
12648 				AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12649 }
12650 
12651 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12652 {
12653 	unsigned int present;
12654 
12655 	present = snd_hda_codec_read(codec, 0x18, 0,
12656 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12657 	snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12658 				0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12659 	snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12660 				0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12661 }
12662 
12663 /* unsolicited event for HP jack sensing */
12664 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12665 				     unsigned int res)
12666 {
12667 	if ((res >> 26) == ALC880_HP_EVENT)
12668 		alc269_speaker_automute(codec);
12669 
12670 	if ((res >> 26) == ALC880_MIC_EVENT)
12671 		alc269_eeepc_dmic_automute(codec);
12672 }
12673 
12674 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12675 {
12676 	alc269_speaker_automute(codec);
12677 	alc269_eeepc_dmic_automute(codec);
12678 }
12679 
12680 /* unsolicited event for HP jack sensing */
12681 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12682 				     unsigned int res)
12683 {
12684 	if ((res >> 26) == ALC880_HP_EVENT)
12685 		alc269_speaker_automute(codec);
12686 
12687 	if ((res >> 26) == ALC880_MIC_EVENT)
12688 		alc269_eeepc_amic_automute(codec);
12689 }
12690 
12691 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12692 {
12693 	alc269_speaker_automute(codec);
12694 	alc269_eeepc_amic_automute(codec);
12695 }
12696 
12697 /*
12698  * generic initialization of ADC, input mixers and output mixers
12699  */
12700 static struct hda_verb alc269_init_verbs[] = {
12701 	/*
12702 	 * Unmute ADC0 and set the default input to mic-in
12703 	 */
12704 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12705 
12706 	/* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12707 	 * analog-loopback mixer widget
12708 	 * Note: PASD motherboards uses the Line In 2 as the input for
12709 	 * front panel mic (mic 2)
12710 	 */
12711 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12712 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12713 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12714 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12715 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12716 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12717 
12718 	/*
12719 	 * Set up output mixers (0x0c - 0x0e)
12720 	 */
12721 	/* set vol=0 to output mixers */
12722 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12723 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12724 
12725 	/* set up input amps for analog loopback */
12726 	/* Amp Indices: DAC = 0, mixer = 1 */
12727 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12728 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12729 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12730 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12731 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12732 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12733 
12734 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12735 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12736 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12737 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12738 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12739 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12740 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12741 
12742 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12743 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12744 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12745 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12746 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12747 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12748 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12749 
12750 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12751 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12752 
12753 	/* FIXME: use matrix-type input source selection */
12754 	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12755 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12756 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12757 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12758 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12759 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12760 
12761 	/* set EAPD */
12762 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12763 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12764 	{ }
12765 };
12766 
12767 /* add playback controls from the parsed DAC table */
12768 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12769 					     const struct auto_pin_cfg *cfg)
12770 {
12771 	hda_nid_t nid;
12772 	int err;
12773 
12774 	spec->multiout.num_dacs = 1;	/* only use one dac */
12775 	spec->multiout.dac_nids = spec->private_dac_nids;
12776 	spec->multiout.dac_nids[0] = 2;
12777 
12778 	nid = cfg->line_out_pins[0];
12779 	if (nid) {
12780 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
12781 				  "Front Playback Volume",
12782 				  HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12783 		if (err < 0)
12784 			return err;
12785 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12786 				  "Front Playback Switch",
12787 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12788 		if (err < 0)
12789 			return err;
12790 	}
12791 
12792 	nid = cfg->speaker_pins[0];
12793 	if (nid) {
12794 		if (!cfg->line_out_pins[0]) {
12795 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
12796 					  "Speaker Playback Volume",
12797 					  HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12798 							      HDA_OUTPUT));
12799 			if (err < 0)
12800 				return err;
12801 		}
12802 		if (nid == 0x16) {
12803 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12804 					  "Speaker Playback Switch",
12805 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12806 							      HDA_OUTPUT));
12807 			if (err < 0)
12808 				return err;
12809 		} else {
12810 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12811 					  "Speaker Playback Switch",
12812 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12813 							      HDA_OUTPUT));
12814 			if (err < 0)
12815 				return err;
12816 		}
12817 	}
12818 	nid = cfg->hp_pins[0];
12819 	if (nid) {
12820 		/* spec->multiout.hp_nid = 2; */
12821 		if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12822 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
12823 					  "Headphone Playback Volume",
12824 					  HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12825 							      HDA_OUTPUT));
12826 			if (err < 0)
12827 				return err;
12828 		}
12829 		if (nid == 0x16) {
12830 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12831 					  "Headphone Playback Switch",
12832 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12833 							      HDA_OUTPUT));
12834 			if (err < 0)
12835 				return err;
12836 		} else {
12837 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12838 					  "Headphone Playback Switch",
12839 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12840 							      HDA_OUTPUT));
12841 			if (err < 0)
12842 				return err;
12843 		}
12844 	}
12845 	return 0;
12846 }
12847 
12848 static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
12849 						const struct auto_pin_cfg *cfg)
12850 {
12851 	int err;
12852 
12853 	err = alc880_auto_create_analog_input_ctls(spec, cfg);
12854 	if (err < 0)
12855 		return err;
12856 	/* digital-mic input pin is excluded in alc880_auto_create..()
12857 	 * because it's under 0x18
12858 	 */
12859 	if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
12860 	    cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
12861 		struct hda_input_mux *imux = &spec->private_imux[0];
12862 		imux->items[imux->num_items].label = "Int Mic";
12863 		imux->items[imux->num_items].index = 0x05;
12864 		imux->num_items++;
12865 	}
12866 	return 0;
12867 }
12868 
12869 #ifdef CONFIG_SND_HDA_POWER_SAVE
12870 #define alc269_loopbacks	alc880_loopbacks
12871 #endif
12872 
12873 /* pcm configuration: identiacal with ALC880 */
12874 #define alc269_pcm_analog_playback	alc880_pcm_analog_playback
12875 #define alc269_pcm_analog_capture	alc880_pcm_analog_capture
12876 #define alc269_pcm_digital_playback	alc880_pcm_digital_playback
12877 #define alc269_pcm_digital_capture	alc880_pcm_digital_capture
12878 
12879 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12880 	.substreams = 1,
12881 	.channels_min = 2,
12882 	.channels_max = 8,
12883 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12884 	/* NID is set in alc_build_pcms */
12885 	.ops = {
12886 		.open = alc880_playback_pcm_open,
12887 		.prepare = alc880_playback_pcm_prepare,
12888 		.cleanup = alc880_playback_pcm_cleanup
12889 	},
12890 };
12891 
12892 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12893 	.substreams = 1,
12894 	.channels_min = 2,
12895 	.channels_max = 2,
12896 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12897 	/* NID is set in alc_build_pcms */
12898 };
12899 
12900 /*
12901  * BIOS auto configuration
12902  */
12903 static int alc269_parse_auto_config(struct hda_codec *codec)
12904 {
12905 	struct alc_spec *spec = codec->spec;
12906 	int err;
12907 	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12908 
12909 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12910 					   alc269_ignore);
12911 	if (err < 0)
12912 		return err;
12913 
12914 	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12915 	if (err < 0)
12916 		return err;
12917 	err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12918 	if (err < 0)
12919 		return err;
12920 
12921 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12922 
12923 	if (spec->autocfg.dig_outs)
12924 		spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12925 
12926 	if (spec->kctls.list)
12927 		add_mixer(spec, spec->kctls.list);
12928 
12929 	add_verb(spec, alc269_init_verbs);
12930 	spec->num_mux_defs = 1;
12931 	spec->input_mux = &spec->private_imux[0];
12932 	/* set default input source */
12933 	snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12934 				  0, AC_VERB_SET_CONNECT_SEL,
12935 				  spec->input_mux->items[0].index);
12936 
12937 	err = alc_auto_add_mic_boost(codec);
12938 	if (err < 0)
12939 		return err;
12940 
12941 	if (!spec->cap_mixer && !spec->no_analog)
12942 		set_capture_mixer(spec);
12943 
12944 	return 1;
12945 }
12946 
12947 #define alc269_auto_init_multi_out	alc882_auto_init_multi_out
12948 #define alc269_auto_init_hp_out		alc882_auto_init_hp_out
12949 #define alc269_auto_init_analog_input	alc882_auto_init_analog_input
12950 
12951 
12952 /* init callback for auto-configuration model -- overriding the default init */
12953 static void alc269_auto_init(struct hda_codec *codec)
12954 {
12955 	struct alc_spec *spec = codec->spec;
12956 	alc269_auto_init_multi_out(codec);
12957 	alc269_auto_init_hp_out(codec);
12958 	alc269_auto_init_analog_input(codec);
12959 	if (spec->unsol_event)
12960 		alc_inithook(codec);
12961 }
12962 
12963 /*
12964  * configuration and preset
12965  */
12966 static const char *alc269_models[ALC269_MODEL_LAST] = {
12967 	[ALC269_BASIC]			= "basic",
12968 	[ALC269_QUANTA_FL1]		= "quanta",
12969 	[ALC269_ASUS_EEEPC_P703]	= "eeepc-p703",
12970 	[ALC269_ASUS_EEEPC_P901]	= "eeepc-p901",
12971 	[ALC269_FUJITSU]		= "fujitsu",
12972 	[ALC269_LIFEBOOK]		= "lifebook"
12973 };
12974 
12975 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12976 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12977 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12978 		      ALC269_ASUS_EEEPC_P703),
12979 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12980 		      ALC269_ASUS_EEEPC_P901),
12981 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12982 		      ALC269_ASUS_EEEPC_P901),
12983 	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12984 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12985 	{}
12986 };
12987 
12988 static struct alc_config_preset alc269_presets[] = {
12989 	[ALC269_BASIC] = {
12990 		.mixers = { alc269_base_mixer },
12991 		.init_verbs = { alc269_init_verbs },
12992 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
12993 		.dac_nids = alc269_dac_nids,
12994 		.hp_nid = 0x03,
12995 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
12996 		.channel_mode = alc269_modes,
12997 		.input_mux = &alc269_capture_source,
12998 	},
12999 	[ALC269_QUANTA_FL1] = {
13000 		.mixers = { alc269_quanta_fl1_mixer },
13001 		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13002 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13003 		.dac_nids = alc269_dac_nids,
13004 		.hp_nid = 0x03,
13005 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13006 		.channel_mode = alc269_modes,
13007 		.input_mux = &alc269_capture_source,
13008 		.unsol_event = alc269_quanta_fl1_unsol_event,
13009 		.init_hook = alc269_quanta_fl1_init_hook,
13010 	},
13011 	[ALC269_ASUS_EEEPC_P703] = {
13012 		.mixers = { alc269_eeepc_mixer },
13013 		.cap_mixer = alc269_epc_capture_mixer,
13014 		.init_verbs = { alc269_init_verbs,
13015 				alc269_eeepc_amic_init_verbs },
13016 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13017 		.dac_nids = alc269_dac_nids,
13018 		.hp_nid = 0x03,
13019 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13020 		.channel_mode = alc269_modes,
13021 		.input_mux = &alc269_eeepc_amic_capture_source,
13022 		.unsol_event = alc269_eeepc_amic_unsol_event,
13023 		.init_hook = alc269_eeepc_amic_inithook,
13024 	},
13025 	[ALC269_ASUS_EEEPC_P901] = {
13026 		.mixers = { alc269_eeepc_mixer },
13027 		.cap_mixer = alc269_epc_capture_mixer,
13028 		.init_verbs = { alc269_init_verbs,
13029 				alc269_eeepc_dmic_init_verbs },
13030 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13031 		.dac_nids = alc269_dac_nids,
13032 		.hp_nid = 0x03,
13033 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13034 		.channel_mode = alc269_modes,
13035 		.input_mux = &alc269_eeepc_dmic_capture_source,
13036 		.unsol_event = alc269_eeepc_dmic_unsol_event,
13037 		.init_hook = alc269_eeepc_dmic_inithook,
13038 	},
13039 	[ALC269_FUJITSU] = {
13040 		.mixers = { alc269_fujitsu_mixer },
13041 		.cap_mixer = alc269_epc_capture_mixer,
13042 		.init_verbs = { alc269_init_verbs,
13043 				alc269_eeepc_dmic_init_verbs },
13044 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13045 		.dac_nids = alc269_dac_nids,
13046 		.hp_nid = 0x03,
13047 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13048 		.channel_mode = alc269_modes,
13049 		.input_mux = &alc269_eeepc_dmic_capture_source,
13050 		.unsol_event = alc269_eeepc_dmic_unsol_event,
13051 		.init_hook = alc269_eeepc_dmic_inithook,
13052 	},
13053 	[ALC269_LIFEBOOK] = {
13054 		.mixers = { alc269_lifebook_mixer },
13055 		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13056 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13057 		.dac_nids = alc269_dac_nids,
13058 		.hp_nid = 0x03,
13059 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13060 		.channel_mode = alc269_modes,
13061 		.input_mux = &alc269_capture_source,
13062 		.unsol_event = alc269_lifebook_unsol_event,
13063 		.init_hook = alc269_lifebook_init_hook,
13064 	},
13065 };
13066 
13067 static int patch_alc269(struct hda_codec *codec)
13068 {
13069 	struct alc_spec *spec;
13070 	int board_config;
13071 	int err;
13072 
13073 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13074 	if (spec == NULL)
13075 		return -ENOMEM;
13076 
13077 	codec->spec = spec;
13078 
13079 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
13080 
13081 	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13082 						  alc269_models,
13083 						  alc269_cfg_tbl);
13084 
13085 	if (board_config < 0) {
13086 		printk(KERN_INFO "hda_codec: Unknown model for ALC269, "
13087 		       "trying auto-probe from BIOS...\n");
13088 		board_config = ALC269_AUTO;
13089 	}
13090 
13091 	if (board_config == ALC269_AUTO) {
13092 		/* automatic parse from the BIOS config */
13093 		err = alc269_parse_auto_config(codec);
13094 		if (err < 0) {
13095 			alc_free(codec);
13096 			return err;
13097 		} else if (!err) {
13098 			printk(KERN_INFO
13099 			       "hda_codec: Cannot set up configuration "
13100 			       "from BIOS.  Using base mode...\n");
13101 			board_config = ALC269_BASIC;
13102 		}
13103 	}
13104 
13105 	err = snd_hda_attach_beep_device(codec, 0x1);
13106 	if (err < 0) {
13107 		alc_free(codec);
13108 		return err;
13109 	}
13110 
13111 	if (board_config != ALC269_AUTO)
13112 		setup_preset(spec, &alc269_presets[board_config]);
13113 
13114 	spec->stream_name_analog = "ALC269 Analog";
13115 	if (codec->subsystem_id == 0x17aa3bf8) {
13116 		/* Due to a hardware problem on Lenovo Ideadpad, we need to
13117 		 * fix the sample rate of analog I/O to 44.1kHz
13118 		 */
13119 		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13120 		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13121 	} else {
13122 		spec->stream_analog_playback = &alc269_pcm_analog_playback;
13123 		spec->stream_analog_capture = &alc269_pcm_analog_capture;
13124 	}
13125 	spec->stream_name_digital = "ALC269 Digital";
13126 	spec->stream_digital_playback = &alc269_pcm_digital_playback;
13127 	spec->stream_digital_capture = &alc269_pcm_digital_capture;
13128 
13129 	spec->adc_nids = alc269_adc_nids;
13130 	spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13131 	spec->capsrc_nids = alc269_capsrc_nids;
13132 	if (!spec->cap_mixer)
13133 		set_capture_mixer(spec);
13134 	set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13135 
13136 	codec->patch_ops = alc_patch_ops;
13137 	if (board_config == ALC269_AUTO)
13138 		spec->init_hook = alc269_auto_init;
13139 #ifdef CONFIG_SND_HDA_POWER_SAVE
13140 	if (!spec->loopback.amplist)
13141 		spec->loopback.amplist = alc269_loopbacks;
13142 #endif
13143 	codec->proc_widget_hook = print_realtek_coef;
13144 
13145 	return 0;
13146 }
13147 
13148 /*
13149  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13150  */
13151 
13152 /*
13153  * set the path ways for 2 channel output
13154  * need to set the codec line out and mic 1 pin widgets to inputs
13155  */
13156 static struct hda_verb alc861_threestack_ch2_init[] = {
13157 	/* set pin widget 1Ah (line in) for input */
13158 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13159 	/* set pin widget 18h (mic1/2) for input, for mic also enable
13160 	 * the vref
13161 	 */
13162 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13163 
13164 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13165 #if 0
13166 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13167 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13168 #endif
13169 	{ } /* end */
13170 };
13171 /*
13172  * 6ch mode
13173  * need to set the codec line out and mic 1 pin widgets to outputs
13174  */
13175 static struct hda_verb alc861_threestack_ch6_init[] = {
13176 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
13177 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13178 	/* set pin widget 18h (mic1) for output (CLFE)*/
13179 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13180 
13181 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13182 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13183 
13184 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13185 #if 0
13186 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13187 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13188 #endif
13189 	{ } /* end */
13190 };
13191 
13192 static struct hda_channel_mode alc861_threestack_modes[2] = {
13193 	{ 2, alc861_threestack_ch2_init },
13194 	{ 6, alc861_threestack_ch6_init },
13195 };
13196 /* Set mic1 as input and unmute the mixer */
13197 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13198 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13199 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13200 	{ } /* end */
13201 };
13202 /* Set mic1 as output and mute mixer */
13203 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13204 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13205 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13206 	{ } /* end */
13207 };
13208 
13209 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13210 	{ 2, alc861_uniwill_m31_ch2_init },
13211 	{ 4, alc861_uniwill_m31_ch4_init },
13212 };
13213 
13214 /* Set mic1 and line-in as input and unmute the mixer */
13215 static struct hda_verb alc861_asus_ch2_init[] = {
13216 	/* set pin widget 1Ah (line in) for input */
13217 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13218 	/* set pin widget 18h (mic1/2) for input, for mic also enable
13219 	 * the vref
13220 	 */
13221 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13222 
13223 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13224 #if 0
13225 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13226 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13227 #endif
13228 	{ } /* end */
13229 };
13230 /* Set mic1 nad line-in as output and mute mixer */
13231 static struct hda_verb alc861_asus_ch6_init[] = {
13232 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
13233 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13234 	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13235 	/* set pin widget 18h (mic1) for output (CLFE)*/
13236 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13237 	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13238 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13239 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13240 
13241 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13242 #if 0
13243 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13244 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13245 #endif
13246 	{ } /* end */
13247 };
13248 
13249 static struct hda_channel_mode alc861_asus_modes[2] = {
13250 	{ 2, alc861_asus_ch2_init },
13251 	{ 6, alc861_asus_ch6_init },
13252 };
13253 
13254 /* patch-ALC861 */
13255 
13256 static struct snd_kcontrol_new alc861_base_mixer[] = {
13257         /* output mixer control */
13258 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13259 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13260 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13261 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13262 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13263 
13264         /*Input mixer control */
13265 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13266 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13267 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13268 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13269 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13270 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13271 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13272 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13273 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13274 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13275 
13276 	{ } /* end */
13277 };
13278 
13279 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13280         /* output mixer control */
13281 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13282 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13283 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13284 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13285 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13286 
13287 	/* Input mixer control */
13288 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13289 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13290 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13291 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13292 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13293 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13294 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13295 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13296 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13297 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13298 
13299 	{
13300 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13301 		.name = "Channel Mode",
13302 		.info = alc_ch_mode_info,
13303 		.get = alc_ch_mode_get,
13304 		.put = alc_ch_mode_put,
13305                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13306 	},
13307 	{ } /* end */
13308 };
13309 
13310 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13311         /* output mixer control */
13312 	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13313 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13314 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13315 
13316 	{ } /* end */
13317 };
13318 
13319 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13320         /* output mixer control */
13321 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13322 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13323 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13324 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13325 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13326 
13327 	/* Input mixer control */
13328 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13329 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13330 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13331 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13332 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13333 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13334 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13335 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13336 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13337 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13338 
13339 	{
13340 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13341 		.name = "Channel Mode",
13342 		.info = alc_ch_mode_info,
13343 		.get = alc_ch_mode_get,
13344 		.put = alc_ch_mode_put,
13345                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13346 	},
13347 	{ } /* end */
13348 };
13349 
13350 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13351         /* output mixer control */
13352 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13353 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13354 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13355 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13356 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13357 
13358 	/* Input mixer control */
13359 	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13360 	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13361 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13362 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13363 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13364 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13365 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13366 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13367 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13368 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13369 
13370 	{
13371 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13372 		.name = "Channel Mode",
13373 		.info = alc_ch_mode_info,
13374 		.get = alc_ch_mode_get,
13375 		.put = alc_ch_mode_put,
13376                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13377 	},
13378 	{ }
13379 };
13380 
13381 /* additional mixer */
13382 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13383 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13384 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13385 	{ }
13386 };
13387 
13388 /*
13389  * generic initialization of ADC, input mixers and output mixers
13390  */
13391 static struct hda_verb alc861_base_init_verbs[] = {
13392 	/*
13393 	 * Unmute ADC0 and set the default input to mic-in
13394 	 */
13395 	/* port-A for surround (rear panel) */
13396 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13397 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13398 	/* port-B for mic-in (rear panel) with vref */
13399 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13400 	/* port-C for line-in (rear panel) */
13401 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13402 	/* port-D for Front */
13403 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13404 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13405 	/* port-E for HP out (front panel) */
13406 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13407 	/* route front PCM to HP */
13408 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13409 	/* port-F for mic-in (front panel) with vref */
13410 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13411 	/* port-G for CLFE (rear panel) */
13412 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13413 	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13414 	/* port-H for side (rear panel) */
13415 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13416 	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13417 	/* CD-in */
13418 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13419 	/* route front mic to ADC1*/
13420 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13421 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13422 
13423 	/* Unmute DAC0~3 & spdif out*/
13424 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13425 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13426 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13427 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13428 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13429 
13430 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13431 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13432         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13433 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13434         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13435 
13436 	/* Unmute Stereo Mixer 15 */
13437 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13438 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13439 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13440 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13441 
13442 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13443 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13444 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13445 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13446 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13447 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13448 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13449 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13450 	/* hp used DAC 3 (Front) */
13451 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13452         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13453 
13454 	{ }
13455 };
13456 
13457 static struct hda_verb alc861_threestack_init_verbs[] = {
13458 	/*
13459 	 * Unmute ADC0 and set the default input to mic-in
13460 	 */
13461 	/* port-A for surround (rear panel) */
13462 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13463 	/* port-B for mic-in (rear panel) with vref */
13464 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13465 	/* port-C for line-in (rear panel) */
13466 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13467 	/* port-D for Front */
13468 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13469 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13470 	/* port-E for HP out (front panel) */
13471 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13472 	/* route front PCM to HP */
13473 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13474 	/* port-F for mic-in (front panel) with vref */
13475 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13476 	/* port-G for CLFE (rear panel) */
13477 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13478 	/* port-H for side (rear panel) */
13479 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13480 	/* CD-in */
13481 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13482 	/* route front mic to ADC1*/
13483 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13484 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13485 	/* Unmute DAC0~3 & spdif out*/
13486 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13487 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13488 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13489 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13490 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13491 
13492 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13493 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13494         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13495 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13496         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13497 
13498 	/* Unmute Stereo Mixer 15 */
13499 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13500 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13501 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13502 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13503 
13504 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13505 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13506 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13507 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13508 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13509 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13510 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13511 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13512 	/* hp used DAC 3 (Front) */
13513 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13514         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13515 	{ }
13516 };
13517 
13518 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13519 	/*
13520 	 * Unmute ADC0 and set the default input to mic-in
13521 	 */
13522 	/* port-A for surround (rear panel) */
13523 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13524 	/* port-B for mic-in (rear panel) with vref */
13525 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13526 	/* port-C for line-in (rear panel) */
13527 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13528 	/* port-D for Front */
13529 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13530 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13531 	/* port-E for HP out (front panel) */
13532 	/* this has to be set to VREF80 */
13533 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13534 	/* route front PCM to HP */
13535 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13536 	/* port-F for mic-in (front panel) with vref */
13537 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13538 	/* port-G for CLFE (rear panel) */
13539 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13540 	/* port-H for side (rear panel) */
13541 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13542 	/* CD-in */
13543 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13544 	/* route front mic to ADC1*/
13545 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13546 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13547 	/* Unmute DAC0~3 & spdif out*/
13548 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13549 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13550 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13551 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13552 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13553 
13554 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13555 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13556         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13557 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13558         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13559 
13560 	/* Unmute Stereo Mixer 15 */
13561 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13562 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13563 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13564 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13565 
13566 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13567 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13568 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13569 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13570 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13571 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13572 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13573 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13574 	/* hp used DAC 3 (Front) */
13575 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13576         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13577 	{ }
13578 };
13579 
13580 static struct hda_verb alc861_asus_init_verbs[] = {
13581 	/*
13582 	 * Unmute ADC0 and set the default input to mic-in
13583 	 */
13584 	/* port-A for surround (rear panel)
13585 	 * according to codec#0 this is the HP jack
13586 	 */
13587 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13588 	/* route front PCM to HP */
13589 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13590 	/* port-B for mic-in (rear panel) with vref */
13591 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13592 	/* port-C for line-in (rear panel) */
13593 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13594 	/* port-D for Front */
13595 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13596 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13597 	/* port-E for HP out (front panel) */
13598 	/* this has to be set to VREF80 */
13599 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13600 	/* route front PCM to HP */
13601 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13602 	/* port-F for mic-in (front panel) with vref */
13603 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13604 	/* port-G for CLFE (rear panel) */
13605 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13606 	/* port-H for side (rear panel) */
13607 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13608 	/* CD-in */
13609 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13610 	/* route front mic to ADC1*/
13611 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13612 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13613 	/* Unmute DAC0~3 & spdif out*/
13614 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13615 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13616 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13617 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13618 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13619 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13620 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13621         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13622 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13623         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13624 
13625 	/* Unmute Stereo Mixer 15 */
13626 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13627 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13628 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13629 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13630 
13631 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13632 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13633 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13634 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13635 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13636 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13637 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13638 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13639 	/* hp used DAC 3 (Front) */
13640 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13641 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13642 	{ }
13643 };
13644 
13645 /* additional init verbs for ASUS laptops */
13646 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13647 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13648 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13649 	{ }
13650 };
13651 
13652 /*
13653  * generic initialization of ADC, input mixers and output mixers
13654  */
13655 static struct hda_verb alc861_auto_init_verbs[] = {
13656 	/*
13657 	 * Unmute ADC0 and set the default input to mic-in
13658 	 */
13659 	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13660 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13661 
13662 	/* Unmute DAC0~3 & spdif out*/
13663 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13664 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13665 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13666 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13667 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13668 
13669 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13670 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13671 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13672 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13673 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13674 
13675 	/* Unmute Stereo Mixer 15 */
13676 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13677 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13678 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13679 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13680 
13681 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13682 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13683 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13684 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13685 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13686 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13687 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13688 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13689 
13690 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13691 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13692 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13693 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13694 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13695 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13696 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13697 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13698 
13699 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
13700 
13701 	{ }
13702 };
13703 
13704 static struct hda_verb alc861_toshiba_init_verbs[] = {
13705 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13706 
13707 	{ }
13708 };
13709 
13710 /* toggle speaker-output according to the hp-jack state */
13711 static void alc861_toshiba_automute(struct hda_codec *codec)
13712 {
13713 	unsigned int present;
13714 
13715 	present = snd_hda_codec_read(codec, 0x0f, 0,
13716 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13717 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13718 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13719 	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13720 				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13721 }
13722 
13723 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13724 				       unsigned int res)
13725 {
13726 	if ((res >> 26) == ALC880_HP_EVENT)
13727 		alc861_toshiba_automute(codec);
13728 }
13729 
13730 /* pcm configuration: identiacal with ALC880 */
13731 #define alc861_pcm_analog_playback	alc880_pcm_analog_playback
13732 #define alc861_pcm_analog_capture	alc880_pcm_analog_capture
13733 #define alc861_pcm_digital_playback	alc880_pcm_digital_playback
13734 #define alc861_pcm_digital_capture	alc880_pcm_digital_capture
13735 
13736 
13737 #define ALC861_DIGOUT_NID	0x07
13738 
13739 static struct hda_channel_mode alc861_8ch_modes[1] = {
13740 	{ 8, NULL }
13741 };
13742 
13743 static hda_nid_t alc861_dac_nids[4] = {
13744 	/* front, surround, clfe, side */
13745 	0x03, 0x06, 0x05, 0x04
13746 };
13747 
13748 static hda_nid_t alc660_dac_nids[3] = {
13749 	/* front, clfe, surround */
13750 	0x03, 0x05, 0x06
13751 };
13752 
13753 static hda_nid_t alc861_adc_nids[1] = {
13754 	/* ADC0-2 */
13755 	0x08,
13756 };
13757 
13758 static struct hda_input_mux alc861_capture_source = {
13759 	.num_items = 5,
13760 	.items = {
13761 		{ "Mic", 0x0 },
13762 		{ "Front Mic", 0x3 },
13763 		{ "Line", 0x1 },
13764 		{ "CD", 0x4 },
13765 		{ "Mixer", 0x5 },
13766 	},
13767 };
13768 
13769 /* fill in the dac_nids table from the parsed pin configuration */
13770 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13771 				     const struct auto_pin_cfg *cfg)
13772 {
13773 	int i;
13774 	hda_nid_t nid;
13775 
13776 	spec->multiout.dac_nids = spec->private_dac_nids;
13777 	for (i = 0; i < cfg->line_outs; i++) {
13778 		nid = cfg->line_out_pins[i];
13779 		if (nid) {
13780 			if (i >= ARRAY_SIZE(alc861_dac_nids))
13781 				continue;
13782 			spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13783 		}
13784 	}
13785 	spec->multiout.num_dacs = cfg->line_outs;
13786 	return 0;
13787 }
13788 
13789 /* add playback controls from the parsed DAC table */
13790 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13791 					     const struct auto_pin_cfg *cfg)
13792 {
13793 	char name[32];
13794 	static const char *chname[4] = {
13795 		"Front", "Surround", NULL /*CLFE*/, "Side"
13796 	};
13797 	hda_nid_t nid;
13798 	int i, idx, err;
13799 
13800 	for (i = 0; i < cfg->line_outs; i++) {
13801 		nid = spec->multiout.dac_nids[i];
13802 		if (!nid)
13803 			continue;
13804 		if (nid == 0x05) {
13805 			/* Center/LFE */
13806 			err = add_control(spec, ALC_CTL_BIND_MUTE,
13807 					  "Center Playback Switch",
13808 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13809 							      HDA_OUTPUT));
13810 			if (err < 0)
13811 				return err;
13812 			err = add_control(spec, ALC_CTL_BIND_MUTE,
13813 					  "LFE Playback Switch",
13814 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13815 							      HDA_OUTPUT));
13816 			if (err < 0)
13817 				return err;
13818 		} else {
13819 			for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13820 			     idx++)
13821 				if (nid == alc861_dac_nids[idx])
13822 					break;
13823 			sprintf(name, "%s Playback Switch", chname[idx]);
13824 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13825 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13826 							      HDA_OUTPUT));
13827 			if (err < 0)
13828 				return err;
13829 		}
13830 	}
13831 	return 0;
13832 }
13833 
13834 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13835 {
13836 	int err;
13837 	hda_nid_t nid;
13838 
13839 	if (!pin)
13840 		return 0;
13841 
13842 	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13843 		nid = 0x03;
13844 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13845 				  "Headphone Playback Switch",
13846 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13847 		if (err < 0)
13848 			return err;
13849 		spec->multiout.hp_nid = nid;
13850 	}
13851 	return 0;
13852 }
13853 
13854 /* create playback/capture controls for input pins */
13855 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13856 						const struct auto_pin_cfg *cfg)
13857 {
13858 	struct hda_input_mux *imux = &spec->private_imux[0];
13859 	int i, err, idx, idx1;
13860 
13861 	for (i = 0; i < AUTO_PIN_LAST; i++) {
13862 		switch (cfg->input_pins[i]) {
13863 		case 0x0c:
13864 			idx1 = 1;
13865 			idx = 2;	/* Line In */
13866 			break;
13867 		case 0x0f:
13868 			idx1 = 2;
13869 			idx = 2;	/* Line In */
13870 			break;
13871 		case 0x0d:
13872 			idx1 = 0;
13873 			idx = 1;	/* Mic In */
13874 			break;
13875 		case 0x10:
13876 			idx1 = 3;
13877 			idx = 1;	/* Mic In */
13878 			break;
13879 		case 0x11:
13880 			idx1 = 4;
13881 			idx = 0;	/* CD */
13882 			break;
13883 		default:
13884 			continue;
13885 		}
13886 
13887 		err = new_analog_input(spec, cfg->input_pins[i],
13888 				       auto_pin_cfg_labels[i], idx, 0x15);
13889 		if (err < 0)
13890 			return err;
13891 
13892 		imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13893 		imux->items[imux->num_items].index = idx1;
13894 		imux->num_items++;
13895 	}
13896 	return 0;
13897 }
13898 
13899 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13900 					      hda_nid_t nid,
13901 					      int pin_type, int dac_idx)
13902 {
13903 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13904 			    pin_type);
13905 	snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13906 			    AMP_OUT_UNMUTE);
13907 }
13908 
13909 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13910 {
13911 	struct alc_spec *spec = codec->spec;
13912 	int i;
13913 
13914 	alc_subsystem_id(codec, 0x0e, 0x0f, 0x0b);
13915 	for (i = 0; i < spec->autocfg.line_outs; i++) {
13916 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
13917 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
13918 		if (nid)
13919 			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13920 							  spec->multiout.dac_nids[i]);
13921 	}
13922 }
13923 
13924 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13925 {
13926 	struct alc_spec *spec = codec->spec;
13927 	hda_nid_t pin;
13928 
13929 	pin = spec->autocfg.hp_pins[0];
13930 	if (pin) /* connect to front */
13931 		alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13932 						  spec->multiout.dac_nids[0]);
13933 	pin = spec->autocfg.speaker_pins[0];
13934 	if (pin)
13935 		alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13936 }
13937 
13938 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13939 {
13940 	struct alc_spec *spec = codec->spec;
13941 	int i;
13942 
13943 	for (i = 0; i < AUTO_PIN_LAST; i++) {
13944 		hda_nid_t nid = spec->autocfg.input_pins[i];
13945 		if (nid >= 0x0c && nid <= 0x11)
13946 			alc_set_input_pin(codec, nid, i);
13947 	}
13948 }
13949 
13950 /* parse the BIOS configuration and set up the alc_spec */
13951 /* return 1 if successful, 0 if the proper config is not found,
13952  * or a negative error code
13953  */
13954 static int alc861_parse_auto_config(struct hda_codec *codec)
13955 {
13956 	struct alc_spec *spec = codec->spec;
13957 	int err;
13958 	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13959 
13960 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13961 					   alc861_ignore);
13962 	if (err < 0)
13963 		return err;
13964 	if (!spec->autocfg.line_outs)
13965 		return 0; /* can't find valid BIOS pin config */
13966 
13967 	err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13968 	if (err < 0)
13969 		return err;
13970 	err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13971 	if (err < 0)
13972 		return err;
13973 	err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13974 	if (err < 0)
13975 		return err;
13976 	err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13977 	if (err < 0)
13978 		return err;
13979 
13980 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13981 
13982 	if (spec->autocfg.dig_outs)
13983 		spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13984 
13985 	if (spec->kctls.list)
13986 		add_mixer(spec, spec->kctls.list);
13987 
13988 	add_verb(spec, alc861_auto_init_verbs);
13989 
13990 	spec->num_mux_defs = 1;
13991 	spec->input_mux = &spec->private_imux[0];
13992 
13993 	spec->adc_nids = alc861_adc_nids;
13994 	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13995 	set_capture_mixer(spec);
13996 
13997 	return 1;
13998 }
13999 
14000 /* additional initialization for auto-configuration model */
14001 static void alc861_auto_init(struct hda_codec *codec)
14002 {
14003 	struct alc_spec *spec = codec->spec;
14004 	alc861_auto_init_multi_out(codec);
14005 	alc861_auto_init_hp_out(codec);
14006 	alc861_auto_init_analog_input(codec);
14007 	if (spec->unsol_event)
14008 		alc_inithook(codec);
14009 }
14010 
14011 #ifdef CONFIG_SND_HDA_POWER_SAVE
14012 static struct hda_amp_list alc861_loopbacks[] = {
14013 	{ 0x15, HDA_INPUT, 0 },
14014 	{ 0x15, HDA_INPUT, 1 },
14015 	{ 0x15, HDA_INPUT, 2 },
14016 	{ 0x15, HDA_INPUT, 3 },
14017 	{ } /* end */
14018 };
14019 #endif
14020 
14021 
14022 /*
14023  * configuration and preset
14024  */
14025 static const char *alc861_models[ALC861_MODEL_LAST] = {
14026 	[ALC861_3ST]		= "3stack",
14027 	[ALC660_3ST]		= "3stack-660",
14028 	[ALC861_3ST_DIG]	= "3stack-dig",
14029 	[ALC861_6ST_DIG]	= "6stack-dig",
14030 	[ALC861_UNIWILL_M31]	= "uniwill-m31",
14031 	[ALC861_TOSHIBA]	= "toshiba",
14032 	[ALC861_ASUS]		= "asus",
14033 	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
14034 	[ALC861_AUTO]		= "auto",
14035 };
14036 
14037 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14038 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14039 	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14040 	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14041 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14042 	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14043 	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14044 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14045 	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14046 	 *        Any other models that need this preset?
14047 	 */
14048 	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14049 	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14050 	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14051 	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14052 	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14053 	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14054 	/* FIXME: the below seems conflict */
14055 	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14056 	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14057 	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14058 	{}
14059 };
14060 
14061 static struct alc_config_preset alc861_presets[] = {
14062 	[ALC861_3ST] = {
14063 		.mixers = { alc861_3ST_mixer },
14064 		.init_verbs = { alc861_threestack_init_verbs },
14065 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14066 		.dac_nids = alc861_dac_nids,
14067 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14068 		.channel_mode = alc861_threestack_modes,
14069 		.need_dac_fix = 1,
14070 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14071 		.adc_nids = alc861_adc_nids,
14072 		.input_mux = &alc861_capture_source,
14073 	},
14074 	[ALC861_3ST_DIG] = {
14075 		.mixers = { alc861_base_mixer },
14076 		.init_verbs = { alc861_threestack_init_verbs },
14077 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14078 		.dac_nids = alc861_dac_nids,
14079 		.dig_out_nid = ALC861_DIGOUT_NID,
14080 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14081 		.channel_mode = alc861_threestack_modes,
14082 		.need_dac_fix = 1,
14083 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14084 		.adc_nids = alc861_adc_nids,
14085 		.input_mux = &alc861_capture_source,
14086 	},
14087 	[ALC861_6ST_DIG] = {
14088 		.mixers = { alc861_base_mixer },
14089 		.init_verbs = { alc861_base_init_verbs },
14090 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14091 		.dac_nids = alc861_dac_nids,
14092 		.dig_out_nid = ALC861_DIGOUT_NID,
14093 		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14094 		.channel_mode = alc861_8ch_modes,
14095 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14096 		.adc_nids = alc861_adc_nids,
14097 		.input_mux = &alc861_capture_source,
14098 	},
14099 	[ALC660_3ST] = {
14100 		.mixers = { alc861_3ST_mixer },
14101 		.init_verbs = { alc861_threestack_init_verbs },
14102 		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
14103 		.dac_nids = alc660_dac_nids,
14104 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14105 		.channel_mode = alc861_threestack_modes,
14106 		.need_dac_fix = 1,
14107 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14108 		.adc_nids = alc861_adc_nids,
14109 		.input_mux = &alc861_capture_source,
14110 	},
14111 	[ALC861_UNIWILL_M31] = {
14112 		.mixers = { alc861_uniwill_m31_mixer },
14113 		.init_verbs = { alc861_uniwill_m31_init_verbs },
14114 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14115 		.dac_nids = alc861_dac_nids,
14116 		.dig_out_nid = ALC861_DIGOUT_NID,
14117 		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14118 		.channel_mode = alc861_uniwill_m31_modes,
14119 		.need_dac_fix = 1,
14120 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14121 		.adc_nids = alc861_adc_nids,
14122 		.input_mux = &alc861_capture_source,
14123 	},
14124 	[ALC861_TOSHIBA] = {
14125 		.mixers = { alc861_toshiba_mixer },
14126 		.init_verbs = { alc861_base_init_verbs,
14127 				alc861_toshiba_init_verbs },
14128 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14129 		.dac_nids = alc861_dac_nids,
14130 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14131 		.channel_mode = alc883_3ST_2ch_modes,
14132 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14133 		.adc_nids = alc861_adc_nids,
14134 		.input_mux = &alc861_capture_source,
14135 		.unsol_event = alc861_toshiba_unsol_event,
14136 		.init_hook = alc861_toshiba_automute,
14137 	},
14138 	[ALC861_ASUS] = {
14139 		.mixers = { alc861_asus_mixer },
14140 		.init_verbs = { alc861_asus_init_verbs },
14141 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14142 		.dac_nids = alc861_dac_nids,
14143 		.dig_out_nid = ALC861_DIGOUT_NID,
14144 		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14145 		.channel_mode = alc861_asus_modes,
14146 		.need_dac_fix = 1,
14147 		.hp_nid = 0x06,
14148 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14149 		.adc_nids = alc861_adc_nids,
14150 		.input_mux = &alc861_capture_source,
14151 	},
14152 	[ALC861_ASUS_LAPTOP] = {
14153 		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14154 		.init_verbs = { alc861_asus_init_verbs,
14155 				alc861_asus_laptop_init_verbs },
14156 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14157 		.dac_nids = alc861_dac_nids,
14158 		.dig_out_nid = ALC861_DIGOUT_NID,
14159 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14160 		.channel_mode = alc883_3ST_2ch_modes,
14161 		.need_dac_fix = 1,
14162 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14163 		.adc_nids = alc861_adc_nids,
14164 		.input_mux = &alc861_capture_source,
14165 	},
14166 };
14167 
14168 
14169 static int patch_alc861(struct hda_codec *codec)
14170 {
14171 	struct alc_spec *spec;
14172 	int board_config;
14173 	int err;
14174 
14175 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14176 	if (spec == NULL)
14177 		return -ENOMEM;
14178 
14179 	codec->spec = spec;
14180 
14181         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14182 						  alc861_models,
14183 						  alc861_cfg_tbl);
14184 
14185 	if (board_config < 0) {
14186 		printk(KERN_INFO "hda_codec: Unknown model for ALC861, "
14187 		       "trying auto-probe from BIOS...\n");
14188 		board_config = ALC861_AUTO;
14189 	}
14190 
14191 	if (board_config == ALC861_AUTO) {
14192 		/* automatic parse from the BIOS config */
14193 		err = alc861_parse_auto_config(codec);
14194 		if (err < 0) {
14195 			alc_free(codec);
14196 			return err;
14197 		} else if (!err) {
14198 			printk(KERN_INFO
14199 			       "hda_codec: Cannot set up configuration "
14200 			       "from BIOS.  Using base mode...\n");
14201 		   board_config = ALC861_3ST_DIG;
14202 		}
14203 	}
14204 
14205 	err = snd_hda_attach_beep_device(codec, 0x23);
14206 	if (err < 0) {
14207 		alc_free(codec);
14208 		return err;
14209 	}
14210 
14211 	if (board_config != ALC861_AUTO)
14212 		setup_preset(spec, &alc861_presets[board_config]);
14213 
14214 	spec->stream_name_analog = "ALC861 Analog";
14215 	spec->stream_analog_playback = &alc861_pcm_analog_playback;
14216 	spec->stream_analog_capture = &alc861_pcm_analog_capture;
14217 
14218 	spec->stream_name_digital = "ALC861 Digital";
14219 	spec->stream_digital_playback = &alc861_pcm_digital_playback;
14220 	spec->stream_digital_capture = &alc861_pcm_digital_capture;
14221 
14222 	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14223 
14224 	spec->vmaster_nid = 0x03;
14225 
14226 	codec->patch_ops = alc_patch_ops;
14227 	if (board_config == ALC861_AUTO)
14228 		spec->init_hook = alc861_auto_init;
14229 #ifdef CONFIG_SND_HDA_POWER_SAVE
14230 	if (!spec->loopback.amplist)
14231 		spec->loopback.amplist = alc861_loopbacks;
14232 #endif
14233 	codec->proc_widget_hook = print_realtek_coef;
14234 
14235 	return 0;
14236 }
14237 
14238 /*
14239  * ALC861-VD support
14240  *
14241  * Based on ALC882
14242  *
14243  * In addition, an independent DAC
14244  */
14245 #define ALC861VD_DIGOUT_NID	0x06
14246 
14247 static hda_nid_t alc861vd_dac_nids[4] = {
14248 	/* front, surr, clfe, side surr */
14249 	0x02, 0x03, 0x04, 0x05
14250 };
14251 
14252 /* dac_nids for ALC660vd are in a different order - according to
14253  * Realtek's driver.
14254  * This should probably tesult in a different mixer for 6stack models
14255  * of ALC660vd codecs, but for now there is only 3stack mixer
14256  * - and it is the same as in 861vd.
14257  * adc_nids in ALC660vd are (is) the same as in 861vd
14258  */
14259 static hda_nid_t alc660vd_dac_nids[3] = {
14260 	/* front, rear, clfe, rear_surr */
14261 	0x02, 0x04, 0x03
14262 };
14263 
14264 static hda_nid_t alc861vd_adc_nids[1] = {
14265 	/* ADC0 */
14266 	0x09,
14267 };
14268 
14269 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14270 
14271 /* input MUX */
14272 /* FIXME: should be a matrix-type input source selection */
14273 static struct hda_input_mux alc861vd_capture_source = {
14274 	.num_items = 4,
14275 	.items = {
14276 		{ "Mic", 0x0 },
14277 		{ "Front Mic", 0x1 },
14278 		{ "Line", 0x2 },
14279 		{ "CD", 0x4 },
14280 	},
14281 };
14282 
14283 static struct hda_input_mux alc861vd_dallas_capture_source = {
14284 	.num_items = 2,
14285 	.items = {
14286 		{ "Ext Mic", 0x0 },
14287 		{ "Int Mic", 0x1 },
14288 	},
14289 };
14290 
14291 static struct hda_input_mux alc861vd_hp_capture_source = {
14292 	.num_items = 2,
14293 	.items = {
14294 		{ "Front Mic", 0x0 },
14295 		{ "ATAPI Mic", 0x1 },
14296 	},
14297 };
14298 
14299 /*
14300  * 2ch mode
14301  */
14302 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14303 	{ 2, NULL }
14304 };
14305 
14306 /*
14307  * 6ch mode
14308  */
14309 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14310 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14311 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14312 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14313 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14314 	{ } /* end */
14315 };
14316 
14317 /*
14318  * 8ch mode
14319  */
14320 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14321 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14322 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14323 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14324 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14325 	{ } /* end */
14326 };
14327 
14328 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14329 	{ 6, alc861vd_6stack_ch6_init },
14330 	{ 8, alc861vd_6stack_ch8_init },
14331 };
14332 
14333 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14334 	{
14335 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14336 		.name = "Channel Mode",
14337 		.info = alc_ch_mode_info,
14338 		.get = alc_ch_mode_get,
14339 		.put = alc_ch_mode_put,
14340 	},
14341 	{ } /* end */
14342 };
14343 
14344 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14345  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14346  */
14347 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14348 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14349 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14350 
14351 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14352 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14353 
14354 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14355 				HDA_OUTPUT),
14356 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14357 				HDA_OUTPUT),
14358 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14359 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14360 
14361 	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14362 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14363 
14364 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14365 
14366 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14367 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14368 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14369 
14370 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14371 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14372 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14373 
14374 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14375 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14376 
14377 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14378 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14379 
14380 	{ } /* end */
14381 };
14382 
14383 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14384 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14385 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14386 
14387 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14388 
14389 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14390 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14391 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14392 
14393 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14394 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14395 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14396 
14397 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14398 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14399 
14400 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14401 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14402 
14403 	{ } /* end */
14404 };
14405 
14406 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14407 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14408 	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14409 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14410 
14411 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14412 
14413 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14414 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14415 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14416 
14417 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14418 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14419 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14420 
14421 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14422 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14423 
14424 	{ } /* end */
14425 };
14426 
14427 /* Pin assignment: Speaker=0x14, HP = 0x15,
14428  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14429  */
14430 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14431 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14432 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14433 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14434 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14435 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14436 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14437 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14438 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14439 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14440 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14441 	{ } /* end */
14442 };
14443 
14444 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14445  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14446  */
14447 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14448 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14449 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14450 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14451 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14452 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14453 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14454 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14455 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14456 
14457 	{ } /* end */
14458 };
14459 
14460 /*
14461  * generic initialization of ADC, input mixers and output mixers
14462  */
14463 static struct hda_verb alc861vd_volume_init_verbs[] = {
14464 	/*
14465 	 * Unmute ADC0 and set the default input to mic-in
14466 	 */
14467 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14468 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14469 
14470 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14471 	 * the analog-loopback mixer widget
14472 	 */
14473 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14474 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14475 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14476 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14477 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14478 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14479 
14480 	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14481 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14482 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14483 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14484 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14485 
14486 	/*
14487 	 * Set up output mixers (0x02 - 0x05)
14488 	 */
14489 	/* set vol=0 to output mixers */
14490 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14491 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14492 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14493 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14494 
14495 	/* set up input amps for analog loopback */
14496 	/* Amp Indices: DAC = 0, mixer = 1 */
14497 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14498 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14499 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14500 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14501 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14502 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14503 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14504 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14505 
14506 	{ }
14507 };
14508 
14509 /*
14510  * 3-stack pin configuration:
14511  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14512  */
14513 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14514 	/*
14515 	 * Set pin mode and muting
14516 	 */
14517 	/* set front pin widgets 0x14 for output */
14518 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14519 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14520 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14521 
14522 	/* Mic (rear) pin: input vref at 80% */
14523 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14524 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14525 	/* Front Mic pin: input vref at 80% */
14526 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14527 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14528 	/* Line In pin: input */
14529 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14530 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14531 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
14532 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14533 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14534 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14535 	/* CD pin widget for input */
14536 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14537 
14538 	{ }
14539 };
14540 
14541 /*
14542  * 6-stack pin configuration:
14543  */
14544 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14545 	/*
14546 	 * Set pin mode and muting
14547 	 */
14548 	/* set front pin widgets 0x14 for output */
14549 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14550 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14551 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14552 
14553 	/* Rear Pin: output 1 (0x0d) */
14554 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14555 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14556 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14557 	/* CLFE Pin: output 2 (0x0e) */
14558 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14559 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14560 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14561 	/* Side Pin: output 3 (0x0f) */
14562 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14563 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14564 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14565 
14566 	/* Mic (rear) pin: input vref at 80% */
14567 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14568 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14569 	/* Front Mic pin: input vref at 80% */
14570 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14571 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14572 	/* Line In pin: input */
14573 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14574 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14575 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
14576 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14577 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14578 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14579 	/* CD pin widget for input */
14580 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14581 
14582 	{ }
14583 };
14584 
14585 static struct hda_verb alc861vd_eapd_verbs[] = {
14586 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14587 	{ }
14588 };
14589 
14590 static struct hda_verb alc660vd_eapd_verbs[] = {
14591 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14592 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14593 	{ }
14594 };
14595 
14596 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14597 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14598 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14599 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14600 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14601 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14602 	{}
14603 };
14604 
14605 /* toggle speaker-output according to the hp-jack state */
14606 static void alc861vd_lenovo_hp_automute(struct hda_codec *codec)
14607 {
14608 	unsigned int present;
14609 	unsigned char bits;
14610 
14611 	present = snd_hda_codec_read(codec, 0x1b, 0,
14612 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14613 	bits = present ? HDA_AMP_MUTE : 0;
14614 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14615 				 HDA_AMP_MUTE, bits);
14616 }
14617 
14618 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14619 {
14620 	unsigned int present;
14621 	unsigned char bits;
14622 
14623 	present = snd_hda_codec_read(codec, 0x18, 0,
14624 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14625 	bits = present ? HDA_AMP_MUTE : 0;
14626 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14627 				 HDA_AMP_MUTE, bits);
14628 }
14629 
14630 static void alc861vd_lenovo_automute(struct hda_codec *codec)
14631 {
14632 	alc861vd_lenovo_hp_automute(codec);
14633 	alc861vd_lenovo_mic_automute(codec);
14634 }
14635 
14636 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14637 					unsigned int res)
14638 {
14639 	switch (res >> 26) {
14640 	case ALC880_HP_EVENT:
14641 		alc861vd_lenovo_hp_automute(codec);
14642 		break;
14643 	case ALC880_MIC_EVENT:
14644 		alc861vd_lenovo_mic_automute(codec);
14645 		break;
14646 	}
14647 }
14648 
14649 static struct hda_verb alc861vd_dallas_verbs[] = {
14650 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14651 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14652 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14653 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14654 
14655 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14656 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14657 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14658 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14659 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14660 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14661 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14662 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14663 
14664 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14665 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14666 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14667 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14668 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14669 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14670 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14671 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14672 
14673 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14674 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14675 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14676 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14677 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14678 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14679 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14680 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14681 
14682 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14683 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14684 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14685 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14686 
14687 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14688 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14689 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14690 
14691 	{ } /* end */
14692 };
14693 
14694 /* toggle speaker-output according to the hp-jack state */
14695 static void alc861vd_dallas_automute(struct hda_codec *codec)
14696 {
14697 	unsigned int present;
14698 
14699 	present = snd_hda_codec_read(codec, 0x15, 0,
14700 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14701 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
14702 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14703 }
14704 
14705 static void alc861vd_dallas_unsol_event(struct hda_codec *codec, unsigned int res)
14706 {
14707 	if ((res >> 26) == ALC880_HP_EVENT)
14708 		alc861vd_dallas_automute(codec);
14709 }
14710 
14711 #ifdef CONFIG_SND_HDA_POWER_SAVE
14712 #define alc861vd_loopbacks	alc880_loopbacks
14713 #endif
14714 
14715 /* pcm configuration: identiacal with ALC880 */
14716 #define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
14717 #define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
14718 #define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
14719 #define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
14720 
14721 /*
14722  * configuration and preset
14723  */
14724 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14725 	[ALC660VD_3ST]		= "3stack-660",
14726 	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
14727 	[ALC660VD_ASUS_V1S]	= "asus-v1s",
14728 	[ALC861VD_3ST]		= "3stack",
14729 	[ALC861VD_3ST_DIG]	= "3stack-digout",
14730 	[ALC861VD_6ST_DIG]	= "6stack-digout",
14731 	[ALC861VD_LENOVO]	= "lenovo",
14732 	[ALC861VD_DALLAS]	= "dallas",
14733 	[ALC861VD_HP]		= "hp",
14734 	[ALC861VD_AUTO]		= "auto",
14735 };
14736 
14737 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14738 	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14739 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14740 	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14741 	SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14742 	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14743 	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14744 	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14745 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14746 	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14747 	SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14748 	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14749 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14750 	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14751 	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14752 	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14753 	{}
14754 };
14755 
14756 static struct alc_config_preset alc861vd_presets[] = {
14757 	[ALC660VD_3ST] = {
14758 		.mixers = { alc861vd_3st_mixer },
14759 		.init_verbs = { alc861vd_volume_init_verbs,
14760 				 alc861vd_3stack_init_verbs },
14761 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14762 		.dac_nids = alc660vd_dac_nids,
14763 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14764 		.channel_mode = alc861vd_3stack_2ch_modes,
14765 		.input_mux = &alc861vd_capture_source,
14766 	},
14767 	[ALC660VD_3ST_DIG] = {
14768 		.mixers = { alc861vd_3st_mixer },
14769 		.init_verbs = { alc861vd_volume_init_verbs,
14770 				 alc861vd_3stack_init_verbs },
14771 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14772 		.dac_nids = alc660vd_dac_nids,
14773 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14774 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14775 		.channel_mode = alc861vd_3stack_2ch_modes,
14776 		.input_mux = &alc861vd_capture_source,
14777 	},
14778 	[ALC861VD_3ST] = {
14779 		.mixers = { alc861vd_3st_mixer },
14780 		.init_verbs = { alc861vd_volume_init_verbs,
14781 				 alc861vd_3stack_init_verbs },
14782 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14783 		.dac_nids = alc861vd_dac_nids,
14784 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14785 		.channel_mode = alc861vd_3stack_2ch_modes,
14786 		.input_mux = &alc861vd_capture_source,
14787 	},
14788 	[ALC861VD_3ST_DIG] = {
14789 		.mixers = { alc861vd_3st_mixer },
14790 		.init_verbs = { alc861vd_volume_init_verbs,
14791 		 		 alc861vd_3stack_init_verbs },
14792 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14793 		.dac_nids = alc861vd_dac_nids,
14794 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14795 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14796 		.channel_mode = alc861vd_3stack_2ch_modes,
14797 		.input_mux = &alc861vd_capture_source,
14798 	},
14799 	[ALC861VD_6ST_DIG] = {
14800 		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14801 		.init_verbs = { alc861vd_volume_init_verbs,
14802 				alc861vd_6stack_init_verbs },
14803 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14804 		.dac_nids = alc861vd_dac_nids,
14805 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14806 		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14807 		.channel_mode = alc861vd_6stack_modes,
14808 		.input_mux = &alc861vd_capture_source,
14809 	},
14810 	[ALC861VD_LENOVO] = {
14811 		.mixers = { alc861vd_lenovo_mixer },
14812 		.init_verbs = { alc861vd_volume_init_verbs,
14813 				alc861vd_3stack_init_verbs,
14814 				alc861vd_eapd_verbs,
14815 				alc861vd_lenovo_unsol_verbs },
14816 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14817 		.dac_nids = alc660vd_dac_nids,
14818 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14819 		.channel_mode = alc861vd_3stack_2ch_modes,
14820 		.input_mux = &alc861vd_capture_source,
14821 		.unsol_event = alc861vd_lenovo_unsol_event,
14822 		.init_hook = alc861vd_lenovo_automute,
14823 	},
14824 	[ALC861VD_DALLAS] = {
14825 		.mixers = { alc861vd_dallas_mixer },
14826 		.init_verbs = { alc861vd_dallas_verbs },
14827 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14828 		.dac_nids = alc861vd_dac_nids,
14829 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14830 		.channel_mode = alc861vd_3stack_2ch_modes,
14831 		.input_mux = &alc861vd_dallas_capture_source,
14832 		.unsol_event = alc861vd_dallas_unsol_event,
14833 		.init_hook = alc861vd_dallas_automute,
14834 	},
14835 	[ALC861VD_HP] = {
14836 		.mixers = { alc861vd_hp_mixer },
14837 		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14838 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14839 		.dac_nids = alc861vd_dac_nids,
14840 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14841 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14842 		.channel_mode = alc861vd_3stack_2ch_modes,
14843 		.input_mux = &alc861vd_hp_capture_source,
14844 		.unsol_event = alc861vd_dallas_unsol_event,
14845 		.init_hook = alc861vd_dallas_automute,
14846 	},
14847 	[ALC660VD_ASUS_V1S] = {
14848 		.mixers = { alc861vd_lenovo_mixer },
14849 		.init_verbs = { alc861vd_volume_init_verbs,
14850 				alc861vd_3stack_init_verbs,
14851 				alc861vd_eapd_verbs,
14852 				alc861vd_lenovo_unsol_verbs },
14853 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14854 		.dac_nids = alc660vd_dac_nids,
14855 		.dig_out_nid = ALC861VD_DIGOUT_NID,
14856 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14857 		.channel_mode = alc861vd_3stack_2ch_modes,
14858 		.input_mux = &alc861vd_capture_source,
14859 		.unsol_event = alc861vd_lenovo_unsol_event,
14860 		.init_hook = alc861vd_lenovo_automute,
14861 	},
14862 };
14863 
14864 /*
14865  * BIOS auto configuration
14866  */
14867 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14868 				hda_nid_t nid, int pin_type, int dac_idx)
14869 {
14870 	alc_set_pin_output(codec, nid, pin_type);
14871 }
14872 
14873 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14874 {
14875 	struct alc_spec *spec = codec->spec;
14876 	int i;
14877 
14878 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
14879 	for (i = 0; i <= HDA_SIDE; i++) {
14880 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
14881 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
14882 		if (nid)
14883 			alc861vd_auto_set_output_and_unmute(codec, nid,
14884 							    pin_type, i);
14885 	}
14886 }
14887 
14888 
14889 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14890 {
14891 	struct alc_spec *spec = codec->spec;
14892 	hda_nid_t pin;
14893 
14894 	pin = spec->autocfg.hp_pins[0];
14895 	if (pin) /* connect to front and  use dac 0 */
14896 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14897 	pin = spec->autocfg.speaker_pins[0];
14898 	if (pin)
14899 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14900 }
14901 
14902 #define alc861vd_is_input_pin(nid)	alc880_is_input_pin(nid)
14903 #define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
14904 
14905 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14906 {
14907 	struct alc_spec *spec = codec->spec;
14908 	int i;
14909 
14910 	for (i = 0; i < AUTO_PIN_LAST; i++) {
14911 		hda_nid_t nid = spec->autocfg.input_pins[i];
14912 		if (alc861vd_is_input_pin(nid)) {
14913 			alc_set_input_pin(codec, nid, i);
14914 			if (nid != ALC861VD_PIN_CD_NID &&
14915 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14916 				snd_hda_codec_write(codec, nid, 0,
14917 						AC_VERB_SET_AMP_GAIN_MUTE,
14918 						AMP_OUT_MUTE);
14919 		}
14920 	}
14921 }
14922 
14923 #define alc861vd_auto_init_input_src	alc882_auto_init_input_src
14924 
14925 #define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
14926 #define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
14927 
14928 /* add playback controls from the parsed DAC table */
14929 /* Based on ALC880 version. But ALC861VD has separate,
14930  * different NIDs for mute/unmute switch and volume control */
14931 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14932 					     const struct auto_pin_cfg *cfg)
14933 {
14934 	char name[32];
14935 	static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14936 	hda_nid_t nid_v, nid_s;
14937 	int i, err;
14938 
14939 	for (i = 0; i < cfg->line_outs; i++) {
14940 		if (!spec->multiout.dac_nids[i])
14941 			continue;
14942 		nid_v = alc861vd_idx_to_mixer_vol(
14943 				alc880_dac_to_idx(
14944 					spec->multiout.dac_nids[i]));
14945 		nid_s = alc861vd_idx_to_mixer_switch(
14946 				alc880_dac_to_idx(
14947 					spec->multiout.dac_nids[i]));
14948 
14949 		if (i == 2) {
14950 			/* Center/LFE */
14951 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
14952 					  "Center Playback Volume",
14953 					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14954 							      HDA_OUTPUT));
14955 			if (err < 0)
14956 				return err;
14957 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
14958 					  "LFE Playback Volume",
14959 					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14960 							      HDA_OUTPUT));
14961 			if (err < 0)
14962 				return err;
14963 			err = add_control(spec, ALC_CTL_BIND_MUTE,
14964 					  "Center Playback Switch",
14965 					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14966 							      HDA_INPUT));
14967 			if (err < 0)
14968 				return err;
14969 			err = add_control(spec, ALC_CTL_BIND_MUTE,
14970 					  "LFE Playback Switch",
14971 					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14972 							      HDA_INPUT));
14973 			if (err < 0)
14974 				return err;
14975 		} else {
14976 			sprintf(name, "%s Playback Volume", chname[i]);
14977 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14978 					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14979 							      HDA_OUTPUT));
14980 			if (err < 0)
14981 				return err;
14982 			sprintf(name, "%s Playback Switch", chname[i]);
14983 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14984 					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14985 							      HDA_INPUT));
14986 			if (err < 0)
14987 				return err;
14988 		}
14989 	}
14990 	return 0;
14991 }
14992 
14993 /* add playback controls for speaker and HP outputs */
14994 /* Based on ALC880 version. But ALC861VD has separate,
14995  * different NIDs for mute/unmute switch and volume control */
14996 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14997 					hda_nid_t pin, const char *pfx)
14998 {
14999 	hda_nid_t nid_v, nid_s;
15000 	int err;
15001 	char name[32];
15002 
15003 	if (!pin)
15004 		return 0;
15005 
15006 	if (alc880_is_fixed_pin(pin)) {
15007 		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15008 		/* specify the DAC as the extra output */
15009 		if (!spec->multiout.hp_nid)
15010 			spec->multiout.hp_nid = nid_v;
15011 		else
15012 			spec->multiout.extra_out_nid[0] = nid_v;
15013 		/* control HP volume/switch on the output mixer amp */
15014 		nid_v = alc861vd_idx_to_mixer_vol(
15015 				alc880_fixed_pin_idx(pin));
15016 		nid_s = alc861vd_idx_to_mixer_switch(
15017 				alc880_fixed_pin_idx(pin));
15018 
15019 		sprintf(name, "%s Playback Volume", pfx);
15020 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15021 				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15022 		if (err < 0)
15023 			return err;
15024 		sprintf(name, "%s Playback Switch", pfx);
15025 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15026 				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15027 		if (err < 0)
15028 			return err;
15029 	} else if (alc880_is_multi_pin(pin)) {
15030 		/* set manual connection */
15031 		/* we have only a switch on HP-out PIN */
15032 		sprintf(name, "%s Playback Switch", pfx);
15033 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15034 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15035 		if (err < 0)
15036 			return err;
15037 	}
15038 	return 0;
15039 }
15040 
15041 /* parse the BIOS configuration and set up the alc_spec
15042  * return 1 if successful, 0 if the proper config is not found,
15043  * or a negative error code
15044  * Based on ALC880 version - had to change it to override
15045  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15046 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15047 {
15048 	struct alc_spec *spec = codec->spec;
15049 	int err;
15050 	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15051 
15052 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15053 					   alc861vd_ignore);
15054 	if (err < 0)
15055 		return err;
15056 	if (!spec->autocfg.line_outs)
15057 		return 0; /* can't find valid BIOS pin config */
15058 
15059 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15060 	if (err < 0)
15061 		return err;
15062 	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15063 	if (err < 0)
15064 		return err;
15065 	err = alc861vd_auto_create_extra_out(spec,
15066 					     spec->autocfg.speaker_pins[0],
15067 					     "Speaker");
15068 	if (err < 0)
15069 		return err;
15070 	err = alc861vd_auto_create_extra_out(spec,
15071 					     spec->autocfg.hp_pins[0],
15072 					     "Headphone");
15073 	if (err < 0)
15074 		return err;
15075 	err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15076 	if (err < 0)
15077 		return err;
15078 
15079 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15080 
15081 	if (spec->autocfg.dig_outs)
15082 		spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15083 
15084 	if (spec->kctls.list)
15085 		add_mixer(spec, spec->kctls.list);
15086 
15087 	add_verb(spec, alc861vd_volume_init_verbs);
15088 
15089 	spec->num_mux_defs = 1;
15090 	spec->input_mux = &spec->private_imux[0];
15091 
15092 	err = alc_auto_add_mic_boost(codec);
15093 	if (err < 0)
15094 		return err;
15095 
15096 	return 1;
15097 }
15098 
15099 /* additional initialization for auto-configuration model */
15100 static void alc861vd_auto_init(struct hda_codec *codec)
15101 {
15102 	struct alc_spec *spec = codec->spec;
15103 	alc861vd_auto_init_multi_out(codec);
15104 	alc861vd_auto_init_hp_out(codec);
15105 	alc861vd_auto_init_analog_input(codec);
15106 	alc861vd_auto_init_input_src(codec);
15107 	if (spec->unsol_event)
15108 		alc_inithook(codec);
15109 }
15110 
15111 static int patch_alc861vd(struct hda_codec *codec)
15112 {
15113 	struct alc_spec *spec;
15114 	int err, board_config;
15115 
15116 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15117 	if (spec == NULL)
15118 		return -ENOMEM;
15119 
15120 	codec->spec = spec;
15121 
15122 	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15123 						  alc861vd_models,
15124 						  alc861vd_cfg_tbl);
15125 
15126 	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15127 		printk(KERN_INFO "hda_codec: Unknown model for ALC660VD/"
15128 			"ALC861VD, trying auto-probe from BIOS...\n");
15129 		board_config = ALC861VD_AUTO;
15130 	}
15131 
15132 	if (board_config == ALC861VD_AUTO) {
15133 		/* automatic parse from the BIOS config */
15134 		err = alc861vd_parse_auto_config(codec);
15135 		if (err < 0) {
15136 			alc_free(codec);
15137 			return err;
15138 		} else if (!err) {
15139 			printk(KERN_INFO
15140 			       "hda_codec: Cannot set up configuration "
15141 			       "from BIOS.  Using base mode...\n");
15142 			board_config = ALC861VD_3ST;
15143 		}
15144 	}
15145 
15146 	err = snd_hda_attach_beep_device(codec, 0x23);
15147 	if (err < 0) {
15148 		alc_free(codec);
15149 		return err;
15150 	}
15151 
15152 	if (board_config != ALC861VD_AUTO)
15153 		setup_preset(spec, &alc861vd_presets[board_config]);
15154 
15155 	if (codec->vendor_id == 0x10ec0660) {
15156 		spec->stream_name_analog = "ALC660-VD Analog";
15157 		spec->stream_name_digital = "ALC660-VD Digital";
15158 		/* always turn on EAPD */
15159 		add_verb(spec, alc660vd_eapd_verbs);
15160 	} else {
15161 		spec->stream_name_analog = "ALC861VD Analog";
15162 		spec->stream_name_digital = "ALC861VD Digital";
15163 	}
15164 
15165 	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15166 	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15167 
15168 	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15169 	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15170 
15171 	spec->adc_nids = alc861vd_adc_nids;
15172 	spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15173 	spec->capsrc_nids = alc861vd_capsrc_nids;
15174 	spec->capture_style = CAPT_MIX;
15175 
15176 	set_capture_mixer(spec);
15177 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15178 
15179 	spec->vmaster_nid = 0x02;
15180 
15181 	codec->patch_ops = alc_patch_ops;
15182 
15183 	if (board_config == ALC861VD_AUTO)
15184 		spec->init_hook = alc861vd_auto_init;
15185 #ifdef CONFIG_SND_HDA_POWER_SAVE
15186 	if (!spec->loopback.amplist)
15187 		spec->loopback.amplist = alc861vd_loopbacks;
15188 #endif
15189 	codec->proc_widget_hook = print_realtek_coef;
15190 
15191 	return 0;
15192 }
15193 
15194 /*
15195  * ALC662 support
15196  *
15197  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15198  * configuration.  Each pin widget can choose any input DACs and a mixer.
15199  * Each ADC is connected from a mixer of all inputs.  This makes possible
15200  * 6-channel independent captures.
15201  *
15202  * In addition, an independent DAC for the multi-playback (not used in this
15203  * driver yet).
15204  */
15205 #define ALC662_DIGOUT_NID	0x06
15206 #define ALC662_DIGIN_NID	0x0a
15207 
15208 static hda_nid_t alc662_dac_nids[4] = {
15209 	/* front, rear, clfe, rear_surr */
15210 	0x02, 0x03, 0x04
15211 };
15212 
15213 static hda_nid_t alc662_adc_nids[1] = {
15214 	/* ADC1-2 */
15215 	0x09,
15216 };
15217 
15218 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15219 
15220 /* input MUX */
15221 /* FIXME: should be a matrix-type input source selection */
15222 static struct hda_input_mux alc662_capture_source = {
15223 	.num_items = 4,
15224 	.items = {
15225 		{ "Mic", 0x0 },
15226 		{ "Front Mic", 0x1 },
15227 		{ "Line", 0x2 },
15228 		{ "CD", 0x4 },
15229 	},
15230 };
15231 
15232 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15233 	.num_items = 2,
15234 	.items = {
15235 		{ "Mic", 0x1 },
15236 		{ "Line", 0x2 },
15237 	},
15238 };
15239 
15240 static struct hda_input_mux alc662_eeepc_capture_source = {
15241 	.num_items = 2,
15242 	.items = {
15243 		{ "i-Mic", 0x1 },
15244 		{ "e-Mic", 0x0 },
15245 	},
15246 };
15247 
15248 static struct hda_input_mux alc663_capture_source = {
15249 	.num_items = 3,
15250 	.items = {
15251 		{ "Mic", 0x0 },
15252 		{ "Front Mic", 0x1 },
15253 		{ "Line", 0x2 },
15254 	},
15255 };
15256 
15257 static struct hda_input_mux alc663_m51va_capture_source = {
15258 	.num_items = 2,
15259 	.items = {
15260 		{ "Ext-Mic", 0x0 },
15261 		{ "D-Mic", 0x9 },
15262 	},
15263 };
15264 
15265 /*
15266  * 2ch mode
15267  */
15268 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15269 	{ 2, NULL }
15270 };
15271 
15272 /*
15273  * 2ch mode
15274  */
15275 static struct hda_verb alc662_3ST_ch2_init[] = {
15276 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15277 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15278 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15279 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15280 	{ } /* end */
15281 };
15282 
15283 /*
15284  * 6ch mode
15285  */
15286 static struct hda_verb alc662_3ST_ch6_init[] = {
15287 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15288 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15289 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15290 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15291 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15292 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15293 	{ } /* end */
15294 };
15295 
15296 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15297 	{ 2, alc662_3ST_ch2_init },
15298 	{ 6, alc662_3ST_ch6_init },
15299 };
15300 
15301 /*
15302  * 2ch mode
15303  */
15304 static struct hda_verb alc662_sixstack_ch6_init[] = {
15305 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15306 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15307 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15308 	{ } /* end */
15309 };
15310 
15311 /*
15312  * 6ch mode
15313  */
15314 static struct hda_verb alc662_sixstack_ch8_init[] = {
15315 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15316 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15317 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15318 	{ } /* end */
15319 };
15320 
15321 static struct hda_channel_mode alc662_5stack_modes[2] = {
15322 	{ 2, alc662_sixstack_ch6_init },
15323 	{ 6, alc662_sixstack_ch8_init },
15324 };
15325 
15326 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15327  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15328  */
15329 
15330 static struct snd_kcontrol_new alc662_base_mixer[] = {
15331 	/* output mixer control */
15332 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15333 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15334 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15335 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15336 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15337 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15338 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15339 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15340 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15341 
15342 	/*Input mixer control */
15343 	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15344 	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15345 	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15346 	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15347 	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15348 	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15349 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15350 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15351 	{ } /* end */
15352 };
15353 
15354 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15355 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15356 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15357 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15358 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15359 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15360 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15361 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15362 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15363 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15364 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15365 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15366 	{ } /* end */
15367 };
15368 
15369 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15370 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15371 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15372 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15373 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15374 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15375 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15376 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15377 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15378 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15379 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15380 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15381 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15382 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15383 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15384 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15385 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15386 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15387 	{ } /* end */
15388 };
15389 
15390 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15391 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15392 	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15393 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15394 	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15395 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15396 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15397 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15398 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15399 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15400 	{ } /* end */
15401 };
15402 
15403 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15404 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15405 
15406 	HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15407 	HDA_CODEC_MUTE("Line-Out Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15408 
15409 	HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15410 	HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15411 	HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15412 
15413 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15414 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15415 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15416 	{ } /* end */
15417 };
15418 
15419 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15420 	HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15421 	HDA_CODEC_MUTE("Line-Out Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15422 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15423 	HDA_BIND_MUTE("Surround Playback Switch", 0x03, 2, HDA_INPUT),
15424 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15425 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15426 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x04, 1, 2, HDA_INPUT),
15427 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x04, 2, 2, HDA_INPUT),
15428 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15429 	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15430 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15431 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15432 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15433 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15434 	{ } /* end */
15435 };
15436 
15437 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15438 	.ops = &snd_hda_bind_vol,
15439 	.values = {
15440 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15441 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15442 		0
15443 	},
15444 };
15445 
15446 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15447 	.ops = &snd_hda_bind_sw,
15448 	.values = {
15449 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15450 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15451 		0
15452 	},
15453 };
15454 
15455 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15456 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15457 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15458 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15459 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15460 	{ } /* end */
15461 };
15462 
15463 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15464 	.ops = &snd_hda_bind_sw,
15465 	.values = {
15466 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15467 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15468 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15469 		0
15470 	},
15471 };
15472 
15473 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15474 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15475 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15476 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15477 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15478 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15479 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15480 
15481 	{ } /* end */
15482 };
15483 
15484 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15485 	.ops = &snd_hda_bind_sw,
15486 	.values = {
15487 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15488 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15489 		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15490 		0
15491 	},
15492 };
15493 
15494 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15495 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15496 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15497 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15498 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15499 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15500 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15501 	{ } /* end */
15502 };
15503 
15504 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15505 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15506 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15507 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15508 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15509 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15510 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15511 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15512 	{ } /* end */
15513 };
15514 
15515 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15516 	.ops = &snd_hda_bind_vol,
15517 	.values = {
15518 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15519 		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15520 		0
15521 	},
15522 };
15523 
15524 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15525 	.ops = &snd_hda_bind_sw,
15526 	.values = {
15527 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15528 		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15529 		0
15530 	},
15531 };
15532 
15533 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15534 	HDA_BIND_VOL("Master Playback Volume",
15535 				&alc663_asus_two_bind_master_vol),
15536 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15537 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15538 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15539 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15540 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15541 	{ } /* end */
15542 };
15543 
15544 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15545 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15546 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15547 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15548 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15549 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15550 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15551 	{ } /* end */
15552 };
15553 
15554 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15555 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15556 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15557 	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15558 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15559 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15560 
15561 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15562 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15563 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15564 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15565 	{ } /* end */
15566 };
15567 
15568 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15569 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15570 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15571 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15572 
15573 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15574 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15575 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15576 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15577 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15578 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15579 	{ } /* end */
15580 };
15581 
15582 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15583 	{
15584 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15585 		.name = "Channel Mode",
15586 		.info = alc_ch_mode_info,
15587 		.get = alc_ch_mode_get,
15588 		.put = alc_ch_mode_put,
15589 	},
15590 	{ } /* end */
15591 };
15592 
15593 static struct hda_verb alc662_init_verbs[] = {
15594 	/* ADC: mute amp left and right */
15595 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15596 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15597 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
15598 
15599 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15600 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15601 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15602 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15603 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15604 
15605 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15606 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15607 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15608 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15609 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15610 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15611 
15612 	/* Front Pin: output 0 (0x0c) */
15613 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15614 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15615 
15616 	/* Rear Pin: output 1 (0x0d) */
15617 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15618 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15619 
15620 	/* CLFE Pin: output 2 (0x0e) */
15621 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15622 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15623 
15624 	/* Mic (rear) pin: input vref at 80% */
15625 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15626 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15627 	/* Front Mic pin: input vref at 80% */
15628 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15629 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15630 	/* Line In pin: input */
15631 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15632 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15633 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
15634 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15635 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15636 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15637 	/* CD pin widget for input */
15638 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15639 
15640 	/* FIXME: use matrix-type input source selection */
15641 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15642 	/* Input mixer */
15643 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15644 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15645 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15646 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15647 
15648 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15649 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15650 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15651 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15652 
15653 	/* always trun on EAPD */
15654 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15655 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15656 
15657 	{ }
15658 };
15659 
15660 static struct hda_verb alc662_sue_init_verbs[] = {
15661 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15662 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15663 	{}
15664 };
15665 
15666 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15667 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15668 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15669 	{}
15670 };
15671 
15672 /* Set Unsolicited Event*/
15673 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15674 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15675 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15676 	{}
15677 };
15678 
15679 /*
15680  * generic initialization of ADC, input mixers and output mixers
15681  */
15682 static struct hda_verb alc662_auto_init_verbs[] = {
15683 	/*
15684 	 * Unmute ADC and set the default input to mic-in
15685 	 */
15686 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15687 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15688 
15689 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15690 	 * mixer widget
15691 	 * Note: PASD motherboards uses the Line In 2 as the input for front
15692 	 * panel mic (mic 2)
15693 	 */
15694 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15695 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15696 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15697 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15698 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15699 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15700 
15701 	/*
15702 	 * Set up output mixers (0x0c - 0x0f)
15703 	 */
15704 	/* set vol=0 to output mixers */
15705 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15706 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15707 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15708 
15709 	/* set up input amps for analog loopback */
15710 	/* Amp Indices: DAC = 0, mixer = 1 */
15711 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15712 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15713 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15714 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15715 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15716 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15717 
15718 
15719 	/* FIXME: use matrix-type input source selection */
15720 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15721 	/* Input mixer */
15722 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15723 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15724 	{ }
15725 };
15726 
15727 /* additional verbs for ALC663 */
15728 static struct hda_verb alc663_auto_init_verbs[] = {
15729 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15730 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15731 	{ }
15732 };
15733 
15734 static struct hda_verb alc663_m51va_init_verbs[] = {
15735 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15736 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15737 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15738 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15739 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15740 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15741 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15742 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15743 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15744 	{}
15745 };
15746 
15747 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15748 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15749 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15750 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15751 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15752 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15753 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15754 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15755 	{}
15756 };
15757 
15758 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15759 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15760 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15761 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15762 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
15763 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15764 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15765 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15766 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15767 	{}
15768 };
15769 
15770 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15771 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15772 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15773 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15774 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15775 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15776 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15777 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15778 	{}
15779 };
15780 
15781 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15782 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15783 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15784 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15785 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
15786 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15787 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15788 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
15789 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15790 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15791 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15792 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15793 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15794 	{}
15795 };
15796 
15797 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15798 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15799 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15800 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15801 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15802 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15803 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15804 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
15805 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15806 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15807 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15808 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15809 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15810 	{}
15811 };
15812 
15813 static struct hda_verb alc663_g71v_init_verbs[] = {
15814 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15815 	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15816 	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15817 
15818 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15819 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15820 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
15821 
15822 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15823 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15824 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15825 	{}
15826 };
15827 
15828 static struct hda_verb alc663_g50v_init_verbs[] = {
15829 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15830 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15831 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
15832 
15833 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15834 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15835 	{}
15836 };
15837 
15838 static struct hda_verb alc662_ecs_init_verbs[] = {
15839 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15840 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15841 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15842 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15843 	{}
15844 };
15845 
15846 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15847 	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15848 	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15849 	{ } /* end */
15850 };
15851 
15852 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15853 {
15854 	unsigned int present;
15855 	unsigned char bits;
15856 
15857 	present = snd_hda_codec_read(codec, 0x14, 0,
15858 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15859 	bits = present ? HDA_AMP_MUTE : 0;
15860 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15861 				 HDA_AMP_MUTE, bits);
15862 }
15863 
15864 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15865 {
15866 	unsigned int present;
15867 	unsigned char bits;
15868 
15869  	present = snd_hda_codec_read(codec, 0x1b, 0,
15870 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15871 	bits = present ? HDA_AMP_MUTE : 0;
15872 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15873 				 HDA_AMP_MUTE, bits);
15874 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15875 				 HDA_AMP_MUTE, bits);
15876 }
15877 
15878 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15879 					   unsigned int res)
15880 {
15881 	if ((res >> 26) == ALC880_HP_EVENT)
15882 		alc662_lenovo_101e_all_automute(codec);
15883 	if ((res >> 26) == ALC880_FRONT_EVENT)
15884 		alc662_lenovo_101e_ispeaker_automute(codec);
15885 }
15886 
15887 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15888 {
15889 	unsigned int present;
15890 
15891 	present = snd_hda_codec_read(codec, 0x18, 0,
15892 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15893 	snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15894 			    0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15895 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15896 			    0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15897 	snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15898 			    0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15899 	snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15900 			    0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15901 }
15902 
15903 /* unsolicited event for HP jack sensing */
15904 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15905 				     unsigned int res)
15906 {
15907 	if ((res >> 26) == ALC880_HP_EVENT)
15908 		alc262_hippo1_automute( codec );
15909 
15910 	if ((res >> 26) == ALC880_MIC_EVENT)
15911 		alc662_eeepc_mic_automute(codec);
15912 }
15913 
15914 static void alc662_eeepc_inithook(struct hda_codec *codec)
15915 {
15916 	alc262_hippo1_automute( codec );
15917 	alc662_eeepc_mic_automute(codec);
15918 }
15919 
15920 static void alc662_eeepc_ep20_automute(struct hda_codec *codec)
15921 {
15922 	unsigned int mute;
15923 	unsigned int present;
15924 
15925 	snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
15926 	present = snd_hda_codec_read(codec, 0x14, 0,
15927 				     AC_VERB_GET_PIN_SENSE, 0);
15928 	present = (present & 0x80000000) != 0;
15929 	if (present) {
15930 		/* mute internal speaker */
15931 		snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15932 					HDA_AMP_MUTE, HDA_AMP_MUTE);
15933 	} else {
15934 		/* unmute internal speaker if necessary */
15935 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
15936 		snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
15937 					HDA_AMP_MUTE, mute);
15938 	}
15939 }
15940 
15941 /* unsolicited event for HP jack sensing */
15942 static void alc662_eeepc_ep20_unsol_event(struct hda_codec *codec,
15943 					  unsigned int res)
15944 {
15945 	if ((res >> 26) == ALC880_HP_EVENT)
15946 		alc662_eeepc_ep20_automute(codec);
15947 }
15948 
15949 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15950 {
15951 	alc662_eeepc_ep20_automute(codec);
15952 }
15953 
15954 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15955 {
15956 	unsigned int present;
15957 	unsigned char bits;
15958 
15959 	present = snd_hda_codec_read(codec, 0x21, 0,
15960 			AC_VERB_GET_PIN_SENSE, 0)
15961 			& AC_PINSENSE_PRESENCE;
15962 	bits = present ? HDA_AMP_MUTE : 0;
15963 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15964 				AMP_IN_MUTE(0), bits);
15965 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15966 				AMP_IN_MUTE(0), bits);
15967 }
15968 
15969 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15970 {
15971 	unsigned int present;
15972 	unsigned char bits;
15973 
15974 	present = snd_hda_codec_read(codec, 0x21, 0,
15975 			AC_VERB_GET_PIN_SENSE, 0)
15976 			& AC_PINSENSE_PRESENCE;
15977 	bits = present ? HDA_AMP_MUTE : 0;
15978 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15979 				AMP_IN_MUTE(0), bits);
15980 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15981 				AMP_IN_MUTE(0), bits);
15982 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
15983 				AMP_IN_MUTE(0), bits);
15984 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
15985 				AMP_IN_MUTE(0), bits);
15986 }
15987 
15988 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
15989 {
15990 	unsigned int present;
15991 	unsigned char bits;
15992 
15993 	present = snd_hda_codec_read(codec, 0x15, 0,
15994 			AC_VERB_GET_PIN_SENSE, 0)
15995 			& AC_PINSENSE_PRESENCE;
15996 	bits = present ? HDA_AMP_MUTE : 0;
15997 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15998 				AMP_IN_MUTE(0), bits);
15999 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16000 				AMP_IN_MUTE(0), bits);
16001 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16002 				AMP_IN_MUTE(0), bits);
16003 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16004 				AMP_IN_MUTE(0), bits);
16005 }
16006 
16007 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16008 {
16009 	unsigned int present;
16010 	unsigned char bits;
16011 
16012 	present = snd_hda_codec_read(codec, 0x1b, 0,
16013 			AC_VERB_GET_PIN_SENSE, 0)
16014 			& AC_PINSENSE_PRESENCE;
16015 	bits = present ? 0 : PIN_OUT;
16016 	snd_hda_codec_write(codec, 0x14, 0,
16017 			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16018 }
16019 
16020 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16021 {
16022 	unsigned int present1, present2;
16023 
16024 	present1 = snd_hda_codec_read(codec, 0x21, 0,
16025 			AC_VERB_GET_PIN_SENSE, 0)
16026 			& AC_PINSENSE_PRESENCE;
16027 	present2 = snd_hda_codec_read(codec, 0x15, 0,
16028 			AC_VERB_GET_PIN_SENSE, 0)
16029 			& AC_PINSENSE_PRESENCE;
16030 
16031 	if (present1 || present2) {
16032 		snd_hda_codec_write_cache(codec, 0x14, 0,
16033 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16034 	} else {
16035 		snd_hda_codec_write_cache(codec, 0x14, 0,
16036 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16037 	}
16038 }
16039 
16040 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16041 {
16042 	unsigned int present1, present2;
16043 
16044 	present1 = snd_hda_codec_read(codec, 0x1b, 0,
16045 				AC_VERB_GET_PIN_SENSE, 0)
16046 				& AC_PINSENSE_PRESENCE;
16047 	present2 = snd_hda_codec_read(codec, 0x15, 0,
16048 				AC_VERB_GET_PIN_SENSE, 0)
16049 				& AC_PINSENSE_PRESENCE;
16050 
16051 	if (present1 || present2) {
16052 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16053 				AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16054 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16055 				AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16056 	} else {
16057 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16058 				AMP_IN_MUTE(0), 0);
16059 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16060 				AMP_IN_MUTE(0), 0);
16061 	}
16062 }
16063 
16064 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16065 {
16066 	unsigned int present;
16067 
16068 	present = snd_hda_codec_read(codec, 0x18, 0,
16069 			AC_VERB_GET_PIN_SENSE, 0)
16070 			& AC_PINSENSE_PRESENCE;
16071 	snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16072 			0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16073 	snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16074 			0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16075 	snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16076 			0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16077 	snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16078 			0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16079 }
16080 
16081 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16082 					   unsigned int res)
16083 {
16084 	switch (res >> 26) {
16085 	case ALC880_HP_EVENT:
16086 		alc663_m51va_speaker_automute(codec);
16087 		break;
16088 	case ALC880_MIC_EVENT:
16089 		alc663_m51va_mic_automute(codec);
16090 		break;
16091 	}
16092 }
16093 
16094 static void alc663_m51va_inithook(struct hda_codec *codec)
16095 {
16096 	alc663_m51va_speaker_automute(codec);
16097 	alc663_m51va_mic_automute(codec);
16098 }
16099 
16100 /* ***************** Mode1 ******************************/
16101 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16102 					   unsigned int res)
16103 {
16104 	switch (res >> 26) {
16105 	case ALC880_HP_EVENT:
16106 		alc663_m51va_speaker_automute(codec);
16107 		break;
16108 	case ALC880_MIC_EVENT:
16109 		alc662_eeepc_mic_automute(codec);
16110 		break;
16111 	}
16112 }
16113 
16114 static void alc663_mode1_inithook(struct hda_codec *codec)
16115 {
16116 	alc663_m51va_speaker_automute(codec);
16117 	alc662_eeepc_mic_automute(codec);
16118 }
16119 /* ***************** Mode2 ******************************/
16120 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16121 					   unsigned int res)
16122 {
16123 	switch (res >> 26) {
16124 	case ALC880_HP_EVENT:
16125 		alc662_f5z_speaker_automute(codec);
16126 		break;
16127 	case ALC880_MIC_EVENT:
16128 		alc662_eeepc_mic_automute(codec);
16129 		break;
16130 	}
16131 }
16132 
16133 static void alc662_mode2_inithook(struct hda_codec *codec)
16134 {
16135 	alc662_f5z_speaker_automute(codec);
16136 	alc662_eeepc_mic_automute(codec);
16137 }
16138 /* ***************** Mode3 ******************************/
16139 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16140 					   unsigned int res)
16141 {
16142 	switch (res >> 26) {
16143 	case ALC880_HP_EVENT:
16144 		alc663_two_hp_m1_speaker_automute(codec);
16145 		break;
16146 	case ALC880_MIC_EVENT:
16147 		alc662_eeepc_mic_automute(codec);
16148 		break;
16149 	}
16150 }
16151 
16152 static void alc663_mode3_inithook(struct hda_codec *codec)
16153 {
16154 	alc663_two_hp_m1_speaker_automute(codec);
16155 	alc662_eeepc_mic_automute(codec);
16156 }
16157 /* ***************** Mode4 ******************************/
16158 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16159 					   unsigned int res)
16160 {
16161 	switch (res >> 26) {
16162 	case ALC880_HP_EVENT:
16163 		alc663_21jd_two_speaker_automute(codec);
16164 		break;
16165 	case ALC880_MIC_EVENT:
16166 		alc662_eeepc_mic_automute(codec);
16167 		break;
16168 	}
16169 }
16170 
16171 static void alc663_mode4_inithook(struct hda_codec *codec)
16172 {
16173 	alc663_21jd_two_speaker_automute(codec);
16174 	alc662_eeepc_mic_automute(codec);
16175 }
16176 /* ***************** Mode5 ******************************/
16177 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16178 					   unsigned int res)
16179 {
16180 	switch (res >> 26) {
16181 	case ALC880_HP_EVENT:
16182 		alc663_15jd_two_speaker_automute(codec);
16183 		break;
16184 	case ALC880_MIC_EVENT:
16185 		alc662_eeepc_mic_automute(codec);
16186 		break;
16187 	}
16188 }
16189 
16190 static void alc663_mode5_inithook(struct hda_codec *codec)
16191 {
16192 	alc663_15jd_two_speaker_automute(codec);
16193 	alc662_eeepc_mic_automute(codec);
16194 }
16195 /* ***************** Mode6 ******************************/
16196 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16197 					   unsigned int res)
16198 {
16199 	switch (res >> 26) {
16200 	case ALC880_HP_EVENT:
16201 		alc663_two_hp_m2_speaker_automute(codec);
16202 		break;
16203 	case ALC880_MIC_EVENT:
16204 		alc662_eeepc_mic_automute(codec);
16205 		break;
16206 	}
16207 }
16208 
16209 static void alc663_mode6_inithook(struct hda_codec *codec)
16210 {
16211 	alc663_two_hp_m2_speaker_automute(codec);
16212 	alc662_eeepc_mic_automute(codec);
16213 }
16214 
16215 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16216 {
16217 	unsigned int present;
16218 	unsigned char bits;
16219 
16220 	present = snd_hda_codec_read(codec, 0x21, 0,
16221 				     AC_VERB_GET_PIN_SENSE, 0)
16222 		& AC_PINSENSE_PRESENCE;
16223 	bits = present ? HDA_AMP_MUTE : 0;
16224 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16225 				 HDA_AMP_MUTE, bits);
16226 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16227 				 HDA_AMP_MUTE, bits);
16228 }
16229 
16230 static void alc663_g71v_front_automute(struct hda_codec *codec)
16231 {
16232 	unsigned int present;
16233 	unsigned char bits;
16234 
16235 	present = snd_hda_codec_read(codec, 0x15, 0,
16236 				     AC_VERB_GET_PIN_SENSE, 0)
16237 		& AC_PINSENSE_PRESENCE;
16238 	bits = present ? HDA_AMP_MUTE : 0;
16239 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16240 				 HDA_AMP_MUTE, bits);
16241 }
16242 
16243 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16244 					   unsigned int res)
16245 {
16246 	switch (res >> 26) {
16247 	case ALC880_HP_EVENT:
16248 		alc663_g71v_hp_automute(codec);
16249 		break;
16250 	case ALC880_FRONT_EVENT:
16251 		alc663_g71v_front_automute(codec);
16252 		break;
16253 	case ALC880_MIC_EVENT:
16254 		alc662_eeepc_mic_automute(codec);
16255 		break;
16256 	}
16257 }
16258 
16259 static void alc663_g71v_inithook(struct hda_codec *codec)
16260 {
16261 	alc663_g71v_front_automute(codec);
16262 	alc663_g71v_hp_automute(codec);
16263 	alc662_eeepc_mic_automute(codec);
16264 }
16265 
16266 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16267 					   unsigned int res)
16268 {
16269 	switch (res >> 26) {
16270 	case ALC880_HP_EVENT:
16271 		alc663_m51va_speaker_automute(codec);
16272 		break;
16273 	case ALC880_MIC_EVENT:
16274 		alc662_eeepc_mic_automute(codec);
16275 		break;
16276 	}
16277 }
16278 
16279 static void alc663_g50v_inithook(struct hda_codec *codec)
16280 {
16281 	alc663_m51va_speaker_automute(codec);
16282 	alc662_eeepc_mic_automute(codec);
16283 }
16284 
16285 /* bind hp and internal speaker mute (with plug check) */
16286 static int alc662_ecs_master_sw_put(struct snd_kcontrol *kcontrol,
16287 				     struct snd_ctl_elem_value *ucontrol)
16288 {
16289 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
16290 	long *valp = ucontrol->value.integer.value;
16291 	int change;
16292 
16293 	change = snd_hda_codec_amp_update(codec, 0x1b, 0, HDA_OUTPUT, 0,
16294 					  HDA_AMP_MUTE,
16295 					  valp[0] ? 0 : HDA_AMP_MUTE);
16296 	change |= snd_hda_codec_amp_update(codec, 0x1b, 1, HDA_OUTPUT, 0,
16297 					   HDA_AMP_MUTE,
16298 					   valp[1] ? 0 : HDA_AMP_MUTE);
16299 	if (change)
16300 		alc262_hippo1_automute(codec);
16301 	return change;
16302 }
16303 
16304 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16305 	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16306 	{
16307 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16308 		.name = "Master Playback Switch",
16309 		.info = snd_hda_mixer_amp_switch_info,
16310 		.get = snd_hda_mixer_amp_switch_get,
16311 		.put = alc662_ecs_master_sw_put,
16312 		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16313 	},
16314 
16315 	HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16316 	HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16317 	HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16318 
16319 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16320 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16321 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16322 	{ } /* end */
16323 };
16324 
16325 #ifdef CONFIG_SND_HDA_POWER_SAVE
16326 #define alc662_loopbacks	alc880_loopbacks
16327 #endif
16328 
16329 
16330 /* pcm configuration: identiacal with ALC880 */
16331 #define alc662_pcm_analog_playback	alc880_pcm_analog_playback
16332 #define alc662_pcm_analog_capture	alc880_pcm_analog_capture
16333 #define alc662_pcm_digital_playback	alc880_pcm_digital_playback
16334 #define alc662_pcm_digital_capture	alc880_pcm_digital_capture
16335 
16336 /*
16337  * configuration and preset
16338  */
16339 static const char *alc662_models[ALC662_MODEL_LAST] = {
16340 	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
16341 	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
16342 	[ALC662_3ST_6ch]	= "3stack-6ch",
16343 	[ALC662_5ST_DIG]	= "6stack-dig",
16344 	[ALC662_LENOVO_101E]	= "lenovo-101e",
16345 	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16346 	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16347 	[ALC662_ECS] = "ecs",
16348 	[ALC663_ASUS_M51VA] = "m51va",
16349 	[ALC663_ASUS_G71V] = "g71v",
16350 	[ALC663_ASUS_H13] = "h13",
16351 	[ALC663_ASUS_G50V] = "g50v",
16352 	[ALC663_ASUS_MODE1] = "asus-mode1",
16353 	[ALC662_ASUS_MODE2] = "asus-mode2",
16354 	[ALC663_ASUS_MODE3] = "asus-mode3",
16355 	[ALC663_ASUS_MODE4] = "asus-mode4",
16356 	[ALC663_ASUS_MODE5] = "asus-mode5",
16357 	[ALC663_ASUS_MODE6] = "asus-mode6",
16358 	[ALC662_AUTO]		= "auto",
16359 };
16360 
16361 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16362 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16363 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16364 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16365 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16366 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16367 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16368 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16369 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16370 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16371 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16372 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16373 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16374 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16375 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16376 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16377 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16378 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16379 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16380 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16381 	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16382 	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16383 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16384 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16385 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16386 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16387 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16388 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16389 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16390 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16391 	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16392 	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16393 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16394 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16395 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16396 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16397 	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16398 	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16399 	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16400 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16401 	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16402 		      ALC662_3ST_6ch_DIG),
16403 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16404 		      ALC662_3ST_6ch_DIG),
16405 	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16406 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16407 	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16408 					ALC662_3ST_6ch_DIG),
16409 	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16410 			   ALC663_ASUS_H13),
16411 	{}
16412 };
16413 
16414 static struct alc_config_preset alc662_presets[] = {
16415 	[ALC662_3ST_2ch_DIG] = {
16416 		.mixers = { alc662_3ST_2ch_mixer },
16417 		.init_verbs = { alc662_init_verbs },
16418 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16419 		.dac_nids = alc662_dac_nids,
16420 		.dig_out_nid = ALC662_DIGOUT_NID,
16421 		.dig_in_nid = ALC662_DIGIN_NID,
16422 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16423 		.channel_mode = alc662_3ST_2ch_modes,
16424 		.input_mux = &alc662_capture_source,
16425 	},
16426 	[ALC662_3ST_6ch_DIG] = {
16427 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16428 		.init_verbs = { alc662_init_verbs },
16429 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16430 		.dac_nids = alc662_dac_nids,
16431 		.dig_out_nid = ALC662_DIGOUT_NID,
16432 		.dig_in_nid = ALC662_DIGIN_NID,
16433 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16434 		.channel_mode = alc662_3ST_6ch_modes,
16435 		.need_dac_fix = 1,
16436 		.input_mux = &alc662_capture_source,
16437 	},
16438 	[ALC662_3ST_6ch] = {
16439 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16440 		.init_verbs = { alc662_init_verbs },
16441 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16442 		.dac_nids = alc662_dac_nids,
16443 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16444 		.channel_mode = alc662_3ST_6ch_modes,
16445 		.need_dac_fix = 1,
16446 		.input_mux = &alc662_capture_source,
16447 	},
16448 	[ALC662_5ST_DIG] = {
16449 		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
16450 		.init_verbs = { alc662_init_verbs },
16451 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16452 		.dac_nids = alc662_dac_nids,
16453 		.dig_out_nid = ALC662_DIGOUT_NID,
16454 		.dig_in_nid = ALC662_DIGIN_NID,
16455 		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16456 		.channel_mode = alc662_5stack_modes,
16457 		.input_mux = &alc662_capture_source,
16458 	},
16459 	[ALC662_LENOVO_101E] = {
16460 		.mixers = { alc662_lenovo_101e_mixer },
16461 		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16462 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16463 		.dac_nids = alc662_dac_nids,
16464 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16465 		.channel_mode = alc662_3ST_2ch_modes,
16466 		.input_mux = &alc662_lenovo_101e_capture_source,
16467 		.unsol_event = alc662_lenovo_101e_unsol_event,
16468 		.init_hook = alc662_lenovo_101e_all_automute,
16469 	},
16470 	[ALC662_ASUS_EEEPC_P701] = {
16471 		.mixers = { alc662_eeepc_p701_mixer },
16472 		.init_verbs = { alc662_init_verbs,
16473 				alc662_eeepc_sue_init_verbs },
16474 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16475 		.dac_nids = alc662_dac_nids,
16476 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16477 		.channel_mode = alc662_3ST_2ch_modes,
16478 		.input_mux = &alc662_eeepc_capture_source,
16479 		.unsol_event = alc662_eeepc_unsol_event,
16480 		.init_hook = alc662_eeepc_inithook,
16481 	},
16482 	[ALC662_ASUS_EEEPC_EP20] = {
16483 		.mixers = { alc662_eeepc_ep20_mixer,
16484 			    alc662_chmode_mixer },
16485 		.init_verbs = { alc662_init_verbs,
16486 				alc662_eeepc_ep20_sue_init_verbs },
16487 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16488 		.dac_nids = alc662_dac_nids,
16489 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16490 		.channel_mode = alc662_3ST_6ch_modes,
16491 		.input_mux = &alc662_lenovo_101e_capture_source,
16492 		.unsol_event = alc662_eeepc_ep20_unsol_event,
16493 		.init_hook = alc662_eeepc_ep20_inithook,
16494 	},
16495 	[ALC662_ECS] = {
16496 		.mixers = { alc662_ecs_mixer },
16497 		.init_verbs = { alc662_init_verbs,
16498 				alc662_ecs_init_verbs },
16499 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16500 		.dac_nids = alc662_dac_nids,
16501 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16502 		.channel_mode = alc662_3ST_2ch_modes,
16503 		.input_mux = &alc662_eeepc_capture_source,
16504 		.unsol_event = alc662_eeepc_unsol_event,
16505 		.init_hook = alc662_eeepc_inithook,
16506 	},
16507 	[ALC663_ASUS_M51VA] = {
16508 		.mixers = { alc663_m51va_mixer },
16509 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16510 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16511 		.dac_nids = alc662_dac_nids,
16512 		.dig_out_nid = ALC662_DIGOUT_NID,
16513 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16514 		.channel_mode = alc662_3ST_2ch_modes,
16515 		.input_mux = &alc663_m51va_capture_source,
16516 		.unsol_event = alc663_m51va_unsol_event,
16517 		.init_hook = alc663_m51va_inithook,
16518 	},
16519 	[ALC663_ASUS_G71V] = {
16520 		.mixers = { alc663_g71v_mixer },
16521 		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16522 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16523 		.dac_nids = alc662_dac_nids,
16524 		.dig_out_nid = ALC662_DIGOUT_NID,
16525 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16526 		.channel_mode = alc662_3ST_2ch_modes,
16527 		.input_mux = &alc662_eeepc_capture_source,
16528 		.unsol_event = alc663_g71v_unsol_event,
16529 		.init_hook = alc663_g71v_inithook,
16530 	},
16531 	[ALC663_ASUS_H13] = {
16532 		.mixers = { alc663_m51va_mixer },
16533 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16534 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16535 		.dac_nids = alc662_dac_nids,
16536 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16537 		.channel_mode = alc662_3ST_2ch_modes,
16538 		.input_mux = &alc663_m51va_capture_source,
16539 		.unsol_event = alc663_m51va_unsol_event,
16540 		.init_hook = alc663_m51va_inithook,
16541 	},
16542 	[ALC663_ASUS_G50V] = {
16543 		.mixers = { alc663_g50v_mixer },
16544 		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16545 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16546 		.dac_nids = alc662_dac_nids,
16547 		.dig_out_nid = ALC662_DIGOUT_NID,
16548 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16549 		.channel_mode = alc662_3ST_6ch_modes,
16550 		.input_mux = &alc663_capture_source,
16551 		.unsol_event = alc663_g50v_unsol_event,
16552 		.init_hook = alc663_g50v_inithook,
16553 	},
16554 	[ALC663_ASUS_MODE1] = {
16555 		.mixers = { alc663_m51va_mixer },
16556 		.cap_mixer = alc662_auto_capture_mixer,
16557 		.init_verbs = { alc662_init_verbs,
16558 				alc663_21jd_amic_init_verbs },
16559 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16560 		.hp_nid = 0x03,
16561 		.dac_nids = alc662_dac_nids,
16562 		.dig_out_nid = ALC662_DIGOUT_NID,
16563 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16564 		.channel_mode = alc662_3ST_2ch_modes,
16565 		.input_mux = &alc662_eeepc_capture_source,
16566 		.unsol_event = alc663_mode1_unsol_event,
16567 		.init_hook = alc663_mode1_inithook,
16568 	},
16569 	[ALC662_ASUS_MODE2] = {
16570 		.mixers = { alc662_1bjd_mixer },
16571 		.cap_mixer = alc662_auto_capture_mixer,
16572 		.init_verbs = { alc662_init_verbs,
16573 				alc662_1bjd_amic_init_verbs },
16574 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16575 		.dac_nids = alc662_dac_nids,
16576 		.dig_out_nid = ALC662_DIGOUT_NID,
16577 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16578 		.channel_mode = alc662_3ST_2ch_modes,
16579 		.input_mux = &alc662_eeepc_capture_source,
16580 		.unsol_event = alc662_mode2_unsol_event,
16581 		.init_hook = alc662_mode2_inithook,
16582 	},
16583 	[ALC663_ASUS_MODE3] = {
16584 		.mixers = { alc663_two_hp_m1_mixer },
16585 		.cap_mixer = alc662_auto_capture_mixer,
16586 		.init_verbs = { alc662_init_verbs,
16587 				alc663_two_hp_amic_m1_init_verbs },
16588 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16589 		.hp_nid = 0x03,
16590 		.dac_nids = alc662_dac_nids,
16591 		.dig_out_nid = ALC662_DIGOUT_NID,
16592 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16593 		.channel_mode = alc662_3ST_2ch_modes,
16594 		.input_mux = &alc662_eeepc_capture_source,
16595 		.unsol_event = alc663_mode3_unsol_event,
16596 		.init_hook = alc663_mode3_inithook,
16597 	},
16598 	[ALC663_ASUS_MODE4] = {
16599 		.mixers = { alc663_asus_21jd_clfe_mixer },
16600 		.cap_mixer = alc662_auto_capture_mixer,
16601 		.init_verbs = { alc662_init_verbs,
16602 				alc663_21jd_amic_init_verbs},
16603 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16604 		.hp_nid = 0x03,
16605 		.dac_nids = alc662_dac_nids,
16606 		.dig_out_nid = ALC662_DIGOUT_NID,
16607 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16608 		.channel_mode = alc662_3ST_2ch_modes,
16609 		.input_mux = &alc662_eeepc_capture_source,
16610 		.unsol_event = alc663_mode4_unsol_event,
16611 		.init_hook = alc663_mode4_inithook,
16612 	},
16613 	[ALC663_ASUS_MODE5] = {
16614 		.mixers = { alc663_asus_15jd_clfe_mixer },
16615 		.cap_mixer = alc662_auto_capture_mixer,
16616 		.init_verbs = { alc662_init_verbs,
16617 				alc663_15jd_amic_init_verbs },
16618 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16619 		.hp_nid = 0x03,
16620 		.dac_nids = alc662_dac_nids,
16621 		.dig_out_nid = ALC662_DIGOUT_NID,
16622 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16623 		.channel_mode = alc662_3ST_2ch_modes,
16624 		.input_mux = &alc662_eeepc_capture_source,
16625 		.unsol_event = alc663_mode5_unsol_event,
16626 		.init_hook = alc663_mode5_inithook,
16627 	},
16628 	[ALC663_ASUS_MODE6] = {
16629 		.mixers = { alc663_two_hp_m2_mixer },
16630 		.cap_mixer = alc662_auto_capture_mixer,
16631 		.init_verbs = { alc662_init_verbs,
16632 				alc663_two_hp_amic_m2_init_verbs },
16633 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16634 		.hp_nid = 0x03,
16635 		.dac_nids = alc662_dac_nids,
16636 		.dig_out_nid = ALC662_DIGOUT_NID,
16637 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16638 		.channel_mode = alc662_3ST_2ch_modes,
16639 		.input_mux = &alc662_eeepc_capture_source,
16640 		.unsol_event = alc663_mode6_unsol_event,
16641 		.init_hook = alc663_mode6_inithook,
16642 	},
16643 };
16644 
16645 
16646 /*
16647  * BIOS auto configuration
16648  */
16649 
16650 /* add playback controls from the parsed DAC table */
16651 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16652 					     const struct auto_pin_cfg *cfg)
16653 {
16654 	char name[32];
16655 	static const char *chname[4] = {
16656 		"Front", "Surround", NULL /*CLFE*/, "Side"
16657 	};
16658 	hda_nid_t nid;
16659 	int i, err;
16660 
16661 	for (i = 0; i < cfg->line_outs; i++) {
16662 		if (!spec->multiout.dac_nids[i])
16663 			continue;
16664 		nid = alc880_idx_to_dac(i);
16665 		if (i == 2) {
16666 			/* Center/LFE */
16667 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
16668 					  "Center Playback Volume",
16669 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16670 							      HDA_OUTPUT));
16671 			if (err < 0)
16672 				return err;
16673 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
16674 					  "LFE Playback Volume",
16675 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16676 							      HDA_OUTPUT));
16677 			if (err < 0)
16678 				return err;
16679 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16680 					  "Center Playback Switch",
16681 					  HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16682 							      HDA_INPUT));
16683 			if (err < 0)
16684 				return err;
16685 			err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16686 					  "LFE Playback Switch",
16687 					  HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16688 							      HDA_INPUT));
16689 			if (err < 0)
16690 				return err;
16691 		} else {
16692 			sprintf(name, "%s Playback Volume", chname[i]);
16693 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16694 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16695 							      HDA_OUTPUT));
16696 			if (err < 0)
16697 				return err;
16698 			sprintf(name, "%s Playback Switch", chname[i]);
16699 			err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16700 				HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16701 						    3, 0, HDA_INPUT));
16702 			if (err < 0)
16703 				return err;
16704 		}
16705 	}
16706 	return 0;
16707 }
16708 
16709 /* add playback controls for speaker and HP outputs */
16710 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16711 					const char *pfx)
16712 {
16713 	hda_nid_t nid;
16714 	int err;
16715 	char name[32];
16716 
16717 	if (!pin)
16718 		return 0;
16719 
16720 	if (pin == 0x17) {
16721 		/* ALC663 has a mono output pin on 0x17 */
16722 		sprintf(name, "%s Playback Switch", pfx);
16723 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16724 				  HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16725 		return err;
16726 	}
16727 
16728 	if (alc880_is_fixed_pin(pin)) {
16729 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16730 		/* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16731 		/* specify the DAC as the extra output */
16732 		if (!spec->multiout.hp_nid)
16733 			spec->multiout.hp_nid = nid;
16734 		else
16735 			spec->multiout.extra_out_nid[0] = nid;
16736 		/* control HP volume/switch on the output mixer amp */
16737 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16738 		sprintf(name, "%s Playback Volume", pfx);
16739 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16740 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16741 		if (err < 0)
16742 			return err;
16743 		sprintf(name, "%s Playback Switch", pfx);
16744 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16745 				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16746 		if (err < 0)
16747 			return err;
16748 	} else if (alc880_is_multi_pin(pin)) {
16749 		/* set manual connection */
16750 		/* we have only a switch on HP-out PIN */
16751 		sprintf(name, "%s Playback Switch", pfx);
16752 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16753 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16754 		if (err < 0)
16755 			return err;
16756 	}
16757 	return 0;
16758 }
16759 
16760 /* return the index of the src widget from the connection list of the nid.
16761  * return -1 if not found
16762  */
16763 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16764 				hda_nid_t src)
16765 {
16766 	hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16767 	int i, conns;
16768 
16769 	conns = snd_hda_get_connections(codec, nid, conn_list,
16770 					ARRAY_SIZE(conn_list));
16771 	if (conns < 0)
16772 		return -1;
16773 	for (i = 0; i < conns; i++)
16774 		if (conn_list[i] == src)
16775 			return i;
16776 	return -1;
16777 }
16778 
16779 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16780 {
16781 	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16782 	return (pincap & AC_PINCAP_IN) != 0;
16783 }
16784 
16785 /* create playback/capture controls for input pins */
16786 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16787 						const struct auto_pin_cfg *cfg)
16788 {
16789 	struct alc_spec *spec = codec->spec;
16790 	struct hda_input_mux *imux = &spec->private_imux[0];
16791 	int i, err, idx;
16792 
16793 	for (i = 0; i < AUTO_PIN_LAST; i++) {
16794 		if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16795 			idx = alc662_input_pin_idx(codec, 0x0b,
16796 						   cfg->input_pins[i]);
16797 			if (idx >= 0) {
16798 				err = new_analog_input(spec, cfg->input_pins[i],
16799 						       auto_pin_cfg_labels[i],
16800 						       idx, 0x0b);
16801 				if (err < 0)
16802 					return err;
16803 			}
16804 			idx = alc662_input_pin_idx(codec, 0x22,
16805 						   cfg->input_pins[i]);
16806 			if (idx >= 0) {
16807 				imux->items[imux->num_items].label =
16808 					auto_pin_cfg_labels[i];
16809 				imux->items[imux->num_items].index = idx;
16810 				imux->num_items++;
16811 			}
16812 		}
16813 	}
16814 	return 0;
16815 }
16816 
16817 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16818 					      hda_nid_t nid, int pin_type,
16819 					      int dac_idx)
16820 {
16821 	alc_set_pin_output(codec, nid, pin_type);
16822 	/* need the manual connection? */
16823 	if (alc880_is_multi_pin(nid)) {
16824 		struct alc_spec *spec = codec->spec;
16825 		int idx = alc880_multi_pin_idx(nid);
16826 		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16827 				    AC_VERB_SET_CONNECT_SEL,
16828 				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16829 	}
16830 }
16831 
16832 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16833 {
16834 	struct alc_spec *spec = codec->spec;
16835 	int i;
16836 
16837 	alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
16838 	for (i = 0; i <= HDA_SIDE; i++) {
16839 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16840 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16841 		if (nid)
16842 			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16843 							  i);
16844 	}
16845 }
16846 
16847 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16848 {
16849 	struct alc_spec *spec = codec->spec;
16850 	hda_nid_t pin;
16851 
16852 	pin = spec->autocfg.hp_pins[0];
16853 	if (pin) /* connect to front */
16854 		/* use dac 0 */
16855 		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16856 	pin = spec->autocfg.speaker_pins[0];
16857 	if (pin)
16858 		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16859 }
16860 
16861 #define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
16862 
16863 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16864 {
16865 	struct alc_spec *spec = codec->spec;
16866 	int i;
16867 
16868 	for (i = 0; i < AUTO_PIN_LAST; i++) {
16869 		hda_nid_t nid = spec->autocfg.input_pins[i];
16870 		if (alc662_is_input_pin(codec, nid)) {
16871 			alc_set_input_pin(codec, nid, i);
16872 			if (nid != ALC662_PIN_CD_NID &&
16873 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16874 				snd_hda_codec_write(codec, nid, 0,
16875 						    AC_VERB_SET_AMP_GAIN_MUTE,
16876 						    AMP_OUT_MUTE);
16877 		}
16878 	}
16879 }
16880 
16881 #define alc662_auto_init_input_src	alc882_auto_init_input_src
16882 
16883 static int alc662_parse_auto_config(struct hda_codec *codec)
16884 {
16885 	struct alc_spec *spec = codec->spec;
16886 	int err;
16887 	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16888 
16889 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16890 					   alc662_ignore);
16891 	if (err < 0)
16892 		return err;
16893 	if (!spec->autocfg.line_outs)
16894 		return 0; /* can't find valid BIOS pin config */
16895 
16896 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16897 	if (err < 0)
16898 		return err;
16899 	err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16900 	if (err < 0)
16901 		return err;
16902 	err = alc662_auto_create_extra_out(spec,
16903 					   spec->autocfg.speaker_pins[0],
16904 					   "Speaker");
16905 	if (err < 0)
16906 		return err;
16907 	err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16908 					   "Headphone");
16909 	if (err < 0)
16910 		return err;
16911 	err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
16912 	if (err < 0)
16913 		return err;
16914 
16915 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16916 
16917 	if (spec->autocfg.dig_outs)
16918 		spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16919 
16920 	if (spec->kctls.list)
16921 		add_mixer(spec, spec->kctls.list);
16922 
16923 	spec->num_mux_defs = 1;
16924 	spec->input_mux = &spec->private_imux[0];
16925 
16926 	add_verb(spec, alc662_auto_init_verbs);
16927 	if (codec->vendor_id == 0x10ec0663)
16928 		add_verb(spec, alc663_auto_init_verbs);
16929 
16930 	err = alc_auto_add_mic_boost(codec);
16931 	if (err < 0)
16932 		return err;
16933 
16934 	return 1;
16935 }
16936 
16937 /* additional initialization for auto-configuration model */
16938 static void alc662_auto_init(struct hda_codec *codec)
16939 {
16940 	struct alc_spec *spec = codec->spec;
16941 	alc662_auto_init_multi_out(codec);
16942 	alc662_auto_init_hp_out(codec);
16943 	alc662_auto_init_analog_input(codec);
16944 	alc662_auto_init_input_src(codec);
16945 	if (spec->unsol_event)
16946 		alc_inithook(codec);
16947 }
16948 
16949 static int patch_alc662(struct hda_codec *codec)
16950 {
16951 	struct alc_spec *spec;
16952 	int err, board_config;
16953 
16954 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16955 	if (!spec)
16956 		return -ENOMEM;
16957 
16958 	codec->spec = spec;
16959 
16960 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
16961 
16962 	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
16963 						  alc662_models,
16964 			  	                  alc662_cfg_tbl);
16965 	if (board_config < 0) {
16966 		printk(KERN_INFO "hda_codec: Unknown model for ALC662, "
16967 		       "trying auto-probe from BIOS...\n");
16968 		board_config = ALC662_AUTO;
16969 	}
16970 
16971 	if (board_config == ALC662_AUTO) {
16972 		/* automatic parse from the BIOS config */
16973 		err = alc662_parse_auto_config(codec);
16974 		if (err < 0) {
16975 			alc_free(codec);
16976 			return err;
16977 		} else if (!err) {
16978 			printk(KERN_INFO
16979 			       "hda_codec: Cannot set up configuration "
16980 			       "from BIOS.  Using base mode...\n");
16981 			board_config = ALC662_3ST_2ch_DIG;
16982 		}
16983 	}
16984 
16985 	err = snd_hda_attach_beep_device(codec, 0x1);
16986 	if (err < 0) {
16987 		alc_free(codec);
16988 		return err;
16989 	}
16990 
16991 	if (board_config != ALC662_AUTO)
16992 		setup_preset(spec, &alc662_presets[board_config]);
16993 
16994 	if (codec->vendor_id == 0x10ec0663) {
16995 		spec->stream_name_analog = "ALC663 Analog";
16996 		spec->stream_name_digital = "ALC663 Digital";
16997 	} else if (codec->vendor_id == 0x10ec0272) {
16998 		spec->stream_name_analog = "ALC272 Analog";
16999 		spec->stream_name_digital = "ALC272 Digital";
17000 	} else {
17001 		spec->stream_name_analog = "ALC662 Analog";
17002 		spec->stream_name_digital = "ALC662 Digital";
17003 	}
17004 
17005 	spec->stream_analog_playback = &alc662_pcm_analog_playback;
17006 	spec->stream_analog_capture = &alc662_pcm_analog_capture;
17007 
17008 	spec->stream_digital_playback = &alc662_pcm_digital_playback;
17009 	spec->stream_digital_capture = &alc662_pcm_digital_capture;
17010 
17011 	spec->adc_nids = alc662_adc_nids;
17012 	spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17013 	spec->capsrc_nids = alc662_capsrc_nids;
17014 	spec->capture_style = CAPT_MIX;
17015 
17016 	if (!spec->cap_mixer)
17017 		set_capture_mixer(spec);
17018 	if (codec->vendor_id == 0x10ec0662)
17019 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17020 	else
17021 		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17022 
17023 	spec->vmaster_nid = 0x02;
17024 
17025 	codec->patch_ops = alc_patch_ops;
17026 	if (board_config == ALC662_AUTO)
17027 		spec->init_hook = alc662_auto_init;
17028 #ifdef CONFIG_SND_HDA_POWER_SAVE
17029 	if (!spec->loopback.amplist)
17030 		spec->loopback.amplist = alc662_loopbacks;
17031 #endif
17032 	codec->proc_widget_hook = print_realtek_coef;
17033 
17034 	return 0;
17035 }
17036 
17037 /*
17038  * patch entries
17039  */
17040 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17041 	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17042 	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17043 	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17044 	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17045 	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17046 	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17047 	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17048 	  .patch = patch_alc861 },
17049 	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17050 	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17051 	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17052 	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17053 	  .patch = patch_alc883 },
17054 	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17055 	  .patch = patch_alc662 },
17056 	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17057 	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17058 	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17059 	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc883 },
17060 	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17061 	  .patch = patch_alc882 }, /* should be patch_alc883() in future */
17062 	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17063 	  .patch = patch_alc882 }, /* should be patch_alc883() in future */
17064 	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17065 	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc883 },
17066 	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17067 	  .patch = patch_alc883 },
17068 	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc883 },
17069 	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc883 },
17070 	{} /* terminator */
17071 };
17072 
17073 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17074 
17075 MODULE_LICENSE("GPL");
17076 MODULE_DESCRIPTION("Realtek HD-audio codec");
17077 
17078 static struct hda_codec_preset_list realtek_list = {
17079 	.preset = snd_hda_preset_realtek,
17080 	.owner = THIS_MODULE,
17081 };
17082 
17083 static int __init patch_realtek_init(void)
17084 {
17085 	return snd_hda_add_codec_preset(&realtek_list);
17086 }
17087 
17088 static void __exit patch_realtek_exit(void)
17089 {
17090 	snd_hda_delete_codec_preset(&realtek_list);
17091 }
17092 
17093 module_init(patch_realtek_init)
17094 module_exit(patch_realtek_exit)
17095