xref: /openbmc/linux/sound/pci/hda/patch_realtek.c (revision e8e0929d) 
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 	ALC272_DELL,
192 	ALC272_DELL_ZM1,
193 	ALC272_SAMSUNG_NC10,
194 	ALC662_AUTO,
195 	ALC662_MODEL_LAST,
196 };
197 
198 /* ALC882 models */
199 enum {
200 	ALC882_3ST_DIG,
201 	ALC882_6ST_DIG,
202 	ALC882_ARIMA,
203 	ALC882_W2JC,
204 	ALC882_TARGA,
205 	ALC882_ASUS_A7J,
206 	ALC882_ASUS_A7M,
207 	ALC885_MACPRO,
208 	ALC885_MBP3,
209 	ALC885_MB5,
210 	ALC885_IMAC24,
211 	ALC883_3ST_2ch_DIG,
212 	ALC883_3ST_6ch_DIG,
213 	ALC883_3ST_6ch,
214 	ALC883_6ST_DIG,
215 	ALC883_TARGA_DIG,
216 	ALC883_TARGA_2ch_DIG,
217 	ALC883_TARGA_8ch_DIG,
218 	ALC883_ACER,
219 	ALC883_ACER_ASPIRE,
220 	ALC888_ACER_ASPIRE_4930G,
221 	ALC888_ACER_ASPIRE_6530G,
222 	ALC888_ACER_ASPIRE_8930G,
223 	ALC888_ACER_ASPIRE_7730G,
224 	ALC883_MEDION,
225 	ALC883_MEDION_MD2,
226 	ALC883_LAPTOP_EAPD,
227 	ALC883_LENOVO_101E_2ch,
228 	ALC883_LENOVO_NB0763,
229 	ALC888_LENOVO_MS7195_DIG,
230 	ALC888_LENOVO_SKY,
231 	ALC883_HAIER_W66,
232 	ALC888_3ST_HP,
233 	ALC888_6ST_DELL,
234 	ALC883_MITAC,
235 	ALC883_CLEVO_M540R,
236 	ALC883_CLEVO_M720,
237 	ALC883_FUJITSU_PI2515,
238 	ALC888_FUJITSU_XA3530,
239 	ALC883_3ST_6ch_INTEL,
240 	ALC889A_INTEL,
241 	ALC889_INTEL,
242 	ALC888_ASUS_M90V,
243 	ALC888_ASUS_EEE1601,
244 	ALC889A_MB31,
245 	ALC1200_ASUS_P5Q,
246 	ALC883_SONY_VAIO_TT,
247 	ALC882_AUTO,
248 	ALC882_MODEL_LAST,
249 };
250 
251 /* for GPIO Poll */
252 #define GPIO_MASK	0x03
253 
254 /* extra amp-initialization sequence types */
255 enum {
256 	ALC_INIT_NONE,
257 	ALC_INIT_DEFAULT,
258 	ALC_INIT_GPIO1,
259 	ALC_INIT_GPIO2,
260 	ALC_INIT_GPIO3,
261 };
262 
263 struct alc_mic_route {
264 	hda_nid_t pin;
265 	unsigned char mux_idx;
266 	unsigned char amix_idx;
267 };
268 
269 #define MUX_IDX_UNDEF	((unsigned char)-1)
270 
271 struct alc_spec {
272 	/* codec parameterization */
273 	struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
274 	unsigned int num_mixers;
275 	struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
276 	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
277 
278 	const struct hda_verb *init_verbs[10];	/* initialization verbs
279 						 * don't forget NULL
280 						 * termination!
281 						 */
282 	unsigned int num_init_verbs;
283 
284 	char stream_name_analog[32];	/* analog PCM stream */
285 	struct hda_pcm_stream *stream_analog_playback;
286 	struct hda_pcm_stream *stream_analog_capture;
287 	struct hda_pcm_stream *stream_analog_alt_playback;
288 	struct hda_pcm_stream *stream_analog_alt_capture;
289 
290 	char stream_name_digital[32];	/* digital PCM stream */
291 	struct hda_pcm_stream *stream_digital_playback;
292 	struct hda_pcm_stream *stream_digital_capture;
293 
294 	/* playback */
295 	struct hda_multi_out multiout;	/* playback set-up
296 					 * max_channels, dacs must be set
297 					 * dig_out_nid and hp_nid are optional
298 					 */
299 	hda_nid_t alt_dac_nid;
300 	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
301 	int dig_out_type;
302 
303 	/* capture */
304 	unsigned int num_adc_nids;
305 	hda_nid_t *adc_nids;
306 	hda_nid_t *capsrc_nids;
307 	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
308 
309 	/* capture source */
310 	unsigned int num_mux_defs;
311 	const struct hda_input_mux *input_mux;
312 	unsigned int cur_mux[3];
313 	struct alc_mic_route ext_mic;
314 	struct alc_mic_route int_mic;
315 
316 	/* channel model */
317 	const struct hda_channel_mode *channel_mode;
318 	int num_channel_mode;
319 	int need_dac_fix;
320 	int const_channel_count;
321 	int ext_channel_count;
322 
323 	/* PCM information */
324 	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
325 
326 	/* dynamic controls, init_verbs and input_mux */
327 	struct auto_pin_cfg autocfg;
328 	struct snd_array kctls;
329 	struct hda_input_mux private_imux[3];
330 	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
331 	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
332 	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
333 
334 	/* hooks */
335 	void (*init_hook)(struct hda_codec *codec);
336 	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
337 
338 	/* for pin sensing */
339 	unsigned int sense_updated: 1;
340 	unsigned int jack_present: 1;
341 	unsigned int master_sw: 1;
342 	unsigned int auto_mic:1;
343 
344 	/* other flags */
345 	unsigned int no_analog :1; /* digital I/O only */
346 	int init_amp;
347 
348 	/* for virtual master */
349 	hda_nid_t vmaster_nid;
350 #ifdef CONFIG_SND_HDA_POWER_SAVE
351 	struct hda_loopback_check loopback;
352 #endif
353 
354 	/* for PLL fix */
355 	hda_nid_t pll_nid;
356 	unsigned int pll_coef_idx, pll_coef_bit;
357 };
358 
359 /*
360  * configuration template - to be copied to the spec instance
361  */
362 struct alc_config_preset {
363 	struct snd_kcontrol_new *mixers[5]; /* should be identical size
364 					     * with spec
365 					     */
366 	struct snd_kcontrol_new *cap_mixer; /* capture mixer */
367 	const struct hda_verb *init_verbs[5];
368 	unsigned int num_dacs;
369 	hda_nid_t *dac_nids;
370 	hda_nid_t dig_out_nid;		/* optional */
371 	hda_nid_t hp_nid;		/* optional */
372 	hda_nid_t *slave_dig_outs;
373 	unsigned int num_adc_nids;
374 	hda_nid_t *adc_nids;
375 	hda_nid_t *capsrc_nids;
376 	hda_nid_t dig_in_nid;
377 	unsigned int num_channel_mode;
378 	const struct hda_channel_mode *channel_mode;
379 	int need_dac_fix;
380 	int const_channel_count;
381 	unsigned int num_mux_defs;
382 	const struct hda_input_mux *input_mux;
383 	void (*unsol_event)(struct hda_codec *, unsigned int);
384 	void (*setup)(struct hda_codec *);
385 	void (*init_hook)(struct hda_codec *);
386 #ifdef CONFIG_SND_HDA_POWER_SAVE
387 	struct hda_amp_list *loopbacks;
388 #endif
389 };
390 
391 
392 /*
393  * input MUX handling
394  */
395 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
396 			     struct snd_ctl_elem_info *uinfo)
397 {
398 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
399 	struct alc_spec *spec = codec->spec;
400 	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
401 	if (mux_idx >= spec->num_mux_defs)
402 		mux_idx = 0;
403 	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
404 }
405 
406 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
407 			    struct snd_ctl_elem_value *ucontrol)
408 {
409 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
410 	struct alc_spec *spec = codec->spec;
411 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
412 
413 	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
414 	return 0;
415 }
416 
417 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
418 			    struct snd_ctl_elem_value *ucontrol)
419 {
420 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
421 	struct alc_spec *spec = codec->spec;
422 	const struct hda_input_mux *imux;
423 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
424 	unsigned int mux_idx;
425 	hda_nid_t nid = spec->capsrc_nids ?
426 		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
427 	unsigned int type;
428 
429 	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
430 	imux = &spec->input_mux[mux_idx];
431 
432 	type = get_wcaps_type(get_wcaps(codec, nid));
433 	if (type == AC_WID_AUD_MIX) {
434 		/* Matrix-mixer style (e.g. ALC882) */
435 		unsigned int *cur_val = &spec->cur_mux[adc_idx];
436 		unsigned int i, idx;
437 
438 		idx = ucontrol->value.enumerated.item[0];
439 		if (idx >= imux->num_items)
440 			idx = imux->num_items - 1;
441 		if (*cur_val == idx)
442 			return 0;
443 		for (i = 0; i < imux->num_items; i++) {
444 			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
445 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
446 						 imux->items[i].index,
447 						 HDA_AMP_MUTE, v);
448 		}
449 		*cur_val = idx;
450 		return 1;
451 	} else {
452 		/* MUX style (e.g. ALC880) */
453 		return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
454 					     &spec->cur_mux[adc_idx]);
455 	}
456 }
457 
458 /*
459  * channel mode setting
460  */
461 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
462 			    struct snd_ctl_elem_info *uinfo)
463 {
464 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
465 	struct alc_spec *spec = codec->spec;
466 	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
467 				    spec->num_channel_mode);
468 }
469 
470 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
471 			   struct snd_ctl_elem_value *ucontrol)
472 {
473 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
474 	struct alc_spec *spec = codec->spec;
475 	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
476 				   spec->num_channel_mode,
477 				   spec->ext_channel_count);
478 }
479 
480 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
481 			   struct snd_ctl_elem_value *ucontrol)
482 {
483 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
484 	struct alc_spec *spec = codec->spec;
485 	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
486 				      spec->num_channel_mode,
487 				      &spec->ext_channel_count);
488 	if (err >= 0 && !spec->const_channel_count) {
489 		spec->multiout.max_channels = spec->ext_channel_count;
490 		if (spec->need_dac_fix)
491 			spec->multiout.num_dacs = spec->multiout.max_channels / 2;
492 	}
493 	return err;
494 }
495 
496 /*
497  * Control the mode of pin widget settings via the mixer.  "pc" is used
498  * instead of "%" to avoid consequences of accidently treating the % as
499  * being part of a format specifier.  Maximum allowed length of a value is
500  * 63 characters plus NULL terminator.
501  *
502  * Note: some retasking pin complexes seem to ignore requests for input
503  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
504  * are requested.  Therefore order this list so that this behaviour will not
505  * cause problems when mixer clients move through the enum sequentially.
506  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
507  * March 2006.
508  */
509 static char *alc_pin_mode_names[] = {
510 	"Mic 50pc bias", "Mic 80pc bias",
511 	"Line in", "Line out", "Headphone out",
512 };
513 static unsigned char alc_pin_mode_values[] = {
514 	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
515 };
516 /* The control can present all 5 options, or it can limit the options based
517  * in the pin being assumed to be exclusively an input or an output pin.  In
518  * addition, "input" pins may or may not process the mic bias option
519  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
520  * accept requests for bias as of chip versions up to March 2006) and/or
521  * wiring in the computer.
522  */
523 #define ALC_PIN_DIR_IN              0x00
524 #define ALC_PIN_DIR_OUT             0x01
525 #define ALC_PIN_DIR_INOUT           0x02
526 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
527 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
528 
529 /* Info about the pin modes supported by the different pin direction modes.
530  * For each direction the minimum and maximum values are given.
531  */
532 static signed char alc_pin_mode_dir_info[5][2] = {
533 	{ 0, 2 },    /* ALC_PIN_DIR_IN */
534 	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
535 	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
536 	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
537 	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
538 };
539 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
540 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
541 #define alc_pin_mode_n_items(_dir) \
542 	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
543 
544 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
545 			     struct snd_ctl_elem_info *uinfo)
546 {
547 	unsigned int item_num = uinfo->value.enumerated.item;
548 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
549 
550 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
551 	uinfo->count = 1;
552 	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
553 
554 	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
555 		item_num = alc_pin_mode_min(dir);
556 	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
557 	return 0;
558 }
559 
560 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
561 			    struct snd_ctl_elem_value *ucontrol)
562 {
563 	unsigned int i;
564 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
565 	hda_nid_t nid = kcontrol->private_value & 0xffff;
566 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
567 	long *valp = ucontrol->value.integer.value;
568 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
569 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
570 						 0x00);
571 
572 	/* Find enumerated value for current pinctl setting */
573 	i = alc_pin_mode_min(dir);
574 	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
575 		i++;
576 	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
577 	return 0;
578 }
579 
580 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
581 			    struct snd_ctl_elem_value *ucontrol)
582 {
583 	signed int change;
584 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
585 	hda_nid_t nid = kcontrol->private_value & 0xffff;
586 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
587 	long val = *ucontrol->value.integer.value;
588 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
589 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
590 						 0x00);
591 
592 	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
593 		val = alc_pin_mode_min(dir);
594 
595 	change = pinctl != alc_pin_mode_values[val];
596 	if (change) {
597 		/* Set pin mode to that requested */
598 		snd_hda_codec_write_cache(codec, nid, 0,
599 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
600 					  alc_pin_mode_values[val]);
601 
602 		/* Also enable the retasking pin's input/output as required
603 		 * for the requested pin mode.  Enum values of 2 or less are
604 		 * input modes.
605 		 *
606 		 * Dynamically switching the input/output buffers probably
607 		 * reduces noise slightly (particularly on input) so we'll
608 		 * do it.  However, having both input and output buffers
609 		 * enabled simultaneously doesn't seem to be problematic if
610 		 * this turns out to be necessary in the future.
611 		 */
612 		if (val <= 2) {
613 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
614 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
615 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
616 						 HDA_AMP_MUTE, 0);
617 		} else {
618 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
619 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
620 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
621 						 HDA_AMP_MUTE, 0);
622 		}
623 	}
624 	return change;
625 }
626 
627 #define ALC_PIN_MODE(xname, nid, dir) \
628 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
629 	  .info = alc_pin_mode_info, \
630 	  .get = alc_pin_mode_get, \
631 	  .put = alc_pin_mode_put, \
632 	  .private_value = nid | (dir<<16) }
633 
634 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
635  * together using a mask with more than one bit set.  This control is
636  * currently used only by the ALC260 test model.  At this stage they are not
637  * needed for any "production" models.
638  */
639 #ifdef CONFIG_SND_DEBUG
640 #define alc_gpio_data_info	snd_ctl_boolean_mono_info
641 
642 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
643 			     struct snd_ctl_elem_value *ucontrol)
644 {
645 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
646 	hda_nid_t nid = kcontrol->private_value & 0xffff;
647 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
648 	long *valp = ucontrol->value.integer.value;
649 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
650 					      AC_VERB_GET_GPIO_DATA, 0x00);
651 
652 	*valp = (val & mask) != 0;
653 	return 0;
654 }
655 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
656 			     struct snd_ctl_elem_value *ucontrol)
657 {
658 	signed int change;
659 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
660 	hda_nid_t nid = kcontrol->private_value & 0xffff;
661 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
662 	long val = *ucontrol->value.integer.value;
663 	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
664 						    AC_VERB_GET_GPIO_DATA,
665 						    0x00);
666 
667 	/* Set/unset the masked GPIO bit(s) as needed */
668 	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
669 	if (val == 0)
670 		gpio_data &= ~mask;
671 	else
672 		gpio_data |= mask;
673 	snd_hda_codec_write_cache(codec, nid, 0,
674 				  AC_VERB_SET_GPIO_DATA, gpio_data);
675 
676 	return change;
677 }
678 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
679 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
680 	  .info = alc_gpio_data_info, \
681 	  .get = alc_gpio_data_get, \
682 	  .put = alc_gpio_data_put, \
683 	  .private_value = nid | (mask<<16) }
684 #endif   /* CONFIG_SND_DEBUG */
685 
686 /* A switch control to allow the enabling of the digital IO pins on the
687  * ALC260.  This is incredibly simplistic; the intention of this control is
688  * to provide something in the test model allowing digital outputs to be
689  * identified if present.  If models are found which can utilise these
690  * outputs a more complete mixer control can be devised for those models if
691  * necessary.
692  */
693 #ifdef CONFIG_SND_DEBUG
694 #define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info
695 
696 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
697 			      struct snd_ctl_elem_value *ucontrol)
698 {
699 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
700 	hda_nid_t nid = kcontrol->private_value & 0xffff;
701 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
702 	long *valp = ucontrol->value.integer.value;
703 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
704 					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);
705 
706 	*valp = (val & mask) != 0;
707 	return 0;
708 }
709 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
710 			      struct snd_ctl_elem_value *ucontrol)
711 {
712 	signed int change;
713 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
714 	hda_nid_t nid = kcontrol->private_value & 0xffff;
715 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
716 	long val = *ucontrol->value.integer.value;
717 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
718 						    AC_VERB_GET_DIGI_CONVERT_1,
719 						    0x00);
720 
721 	/* Set/unset the masked control bit(s) as needed */
722 	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
723 	if (val==0)
724 		ctrl_data &= ~mask;
725 	else
726 		ctrl_data |= mask;
727 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
728 				  ctrl_data);
729 
730 	return change;
731 }
732 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
733 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
734 	  .info = alc_spdif_ctrl_info, \
735 	  .get = alc_spdif_ctrl_get, \
736 	  .put = alc_spdif_ctrl_put, \
737 	  .private_value = nid | (mask<<16) }
738 #endif   /* CONFIG_SND_DEBUG */
739 
740 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
741  * Again, this is only used in the ALC26x test models to help identify when
742  * the EAPD line must be asserted for features to work.
743  */
744 #ifdef CONFIG_SND_DEBUG
745 #define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info
746 
747 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
748 			      struct snd_ctl_elem_value *ucontrol)
749 {
750 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
751 	hda_nid_t nid = kcontrol->private_value & 0xffff;
752 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
753 	long *valp = ucontrol->value.integer.value;
754 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
755 					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);
756 
757 	*valp = (val & mask) != 0;
758 	return 0;
759 }
760 
761 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
762 			      struct snd_ctl_elem_value *ucontrol)
763 {
764 	int change;
765 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
766 	hda_nid_t nid = kcontrol->private_value & 0xffff;
767 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
768 	long val = *ucontrol->value.integer.value;
769 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
770 						    AC_VERB_GET_EAPD_BTLENABLE,
771 						    0x00);
772 
773 	/* Set/unset the masked control bit(s) as needed */
774 	change = (!val ? 0 : mask) != (ctrl_data & mask);
775 	if (!val)
776 		ctrl_data &= ~mask;
777 	else
778 		ctrl_data |= mask;
779 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
780 				  ctrl_data);
781 
782 	return change;
783 }
784 
785 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
786 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
787 	  .info = alc_eapd_ctrl_info, \
788 	  .get = alc_eapd_ctrl_get, \
789 	  .put = alc_eapd_ctrl_put, \
790 	  .private_value = nid | (mask<<16) }
791 #endif   /* CONFIG_SND_DEBUG */
792 
793 /*
794  * set up the input pin config (depending on the given auto-pin type)
795  */
796 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
797 			      int auto_pin_type)
798 {
799 	unsigned int val = PIN_IN;
800 
801 	if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
802 		unsigned int pincap;
803 		pincap = snd_hda_query_pin_caps(codec, nid);
804 		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
805 		if (pincap & AC_PINCAP_VREF_80)
806 			val = PIN_VREF80;
807 		else if (pincap & AC_PINCAP_VREF_50)
808 			val = PIN_VREF50;
809 		else if (pincap & AC_PINCAP_VREF_100)
810 			val = PIN_VREF100;
811 		else if (pincap & AC_PINCAP_VREF_GRD)
812 			val = PIN_VREFGRD;
813 	}
814 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
815 }
816 
817 /*
818  */
819 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
820 {
821 	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
822 		return;
823 	spec->mixers[spec->num_mixers++] = mix;
824 }
825 
826 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
827 {
828 	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
829 		return;
830 	spec->init_verbs[spec->num_init_verbs++] = verb;
831 }
832 
833 #ifdef CONFIG_PROC_FS
834 /*
835  * hook for proc
836  */
837 static void print_realtek_coef(struct snd_info_buffer *buffer,
838 			       struct hda_codec *codec, hda_nid_t nid)
839 {
840 	int coeff;
841 
842 	if (nid != 0x20)
843 		return;
844 	coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
845 	snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
846 	coeff = snd_hda_codec_read(codec, nid, 0,
847 				   AC_VERB_GET_COEF_INDEX, 0);
848 	snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
849 }
850 #else
851 #define print_realtek_coef	NULL
852 #endif
853 
854 /*
855  * set up from the preset table
856  */
857 static void setup_preset(struct hda_codec *codec,
858 			 const struct alc_config_preset *preset)
859 {
860 	struct alc_spec *spec = codec->spec;
861 	int i;
862 
863 	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
864 		add_mixer(spec, preset->mixers[i]);
865 	spec->cap_mixer = preset->cap_mixer;
866 	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
867 	     i++)
868 		add_verb(spec, preset->init_verbs[i]);
869 
870 	spec->channel_mode = preset->channel_mode;
871 	spec->num_channel_mode = preset->num_channel_mode;
872 	spec->need_dac_fix = preset->need_dac_fix;
873 	spec->const_channel_count = preset->const_channel_count;
874 
875 	if (preset->const_channel_count)
876 		spec->multiout.max_channels = preset->const_channel_count;
877 	else
878 		spec->multiout.max_channels = spec->channel_mode[0].channels;
879 	spec->ext_channel_count = spec->channel_mode[0].channels;
880 
881 	spec->multiout.num_dacs = preset->num_dacs;
882 	spec->multiout.dac_nids = preset->dac_nids;
883 	spec->multiout.dig_out_nid = preset->dig_out_nid;
884 	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
885 	spec->multiout.hp_nid = preset->hp_nid;
886 
887 	spec->num_mux_defs = preset->num_mux_defs;
888 	if (!spec->num_mux_defs)
889 		spec->num_mux_defs = 1;
890 	spec->input_mux = preset->input_mux;
891 
892 	spec->num_adc_nids = preset->num_adc_nids;
893 	spec->adc_nids = preset->adc_nids;
894 	spec->capsrc_nids = preset->capsrc_nids;
895 	spec->dig_in_nid = preset->dig_in_nid;
896 
897 	spec->unsol_event = preset->unsol_event;
898 	spec->init_hook = preset->init_hook;
899 #ifdef CONFIG_SND_HDA_POWER_SAVE
900 	spec->loopback.amplist = preset->loopbacks;
901 #endif
902 
903 	if (preset->setup)
904 		preset->setup(codec);
905 }
906 
907 /* Enable GPIO mask and set output */
908 static struct hda_verb alc_gpio1_init_verbs[] = {
909 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
910 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
911 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
912 	{ }
913 };
914 
915 static struct hda_verb alc_gpio2_init_verbs[] = {
916 	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
917 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
918 	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
919 	{ }
920 };
921 
922 static struct hda_verb alc_gpio3_init_verbs[] = {
923 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
924 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
925 	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
926 	{ }
927 };
928 
929 /*
930  * Fix hardware PLL issue
931  * On some codecs, the analog PLL gating control must be off while
932  * the default value is 1.
933  */
934 static void alc_fix_pll(struct hda_codec *codec)
935 {
936 	struct alc_spec *spec = codec->spec;
937 	unsigned int val;
938 
939 	if (!spec->pll_nid)
940 		return;
941 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
942 			    spec->pll_coef_idx);
943 	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
944 				 AC_VERB_GET_PROC_COEF, 0);
945 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
946 			    spec->pll_coef_idx);
947 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
948 			    val & ~(1 << spec->pll_coef_bit));
949 }
950 
951 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
952 			     unsigned int coef_idx, unsigned int coef_bit)
953 {
954 	struct alc_spec *spec = codec->spec;
955 	spec->pll_nid = nid;
956 	spec->pll_coef_idx = coef_idx;
957 	spec->pll_coef_bit = coef_bit;
958 	alc_fix_pll(codec);
959 }
960 
961 static void alc_automute_pin(struct hda_codec *codec)
962 {
963 	struct alc_spec *spec = codec->spec;
964 	unsigned int present, pincap;
965 	unsigned int nid = spec->autocfg.hp_pins[0];
966 	int i;
967 
968 	pincap = snd_hda_query_pin_caps(codec, nid);
969 	if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
970 		snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
971 	present = snd_hda_codec_read(codec, nid, 0,
972 				     AC_VERB_GET_PIN_SENSE, 0);
973 	spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
974 	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
975 		nid = spec->autocfg.speaker_pins[i];
976 		if (!nid)
977 			break;
978 		snd_hda_codec_write(codec, nid, 0,
979 				    AC_VERB_SET_PIN_WIDGET_CONTROL,
980 				    spec->jack_present ? 0 : PIN_OUT);
981 	}
982 }
983 
984 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
985 				hda_nid_t nid)
986 {
987 	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
988 	int i, nums;
989 
990 	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
991 	for (i = 0; i < nums; i++)
992 		if (conn[i] == nid)
993 			return i;
994 	return -1;
995 }
996 
997 static void alc_mic_automute(struct hda_codec *codec)
998 {
999 	struct alc_spec *spec = codec->spec;
1000 	struct alc_mic_route *dead, *alive;
1001 	unsigned int present, type;
1002 	hda_nid_t cap_nid;
1003 
1004 	if (!spec->auto_mic)
1005 		return;
1006 	if (!spec->int_mic.pin || !spec->ext_mic.pin)
1007 		return;
1008 	if (snd_BUG_ON(!spec->adc_nids))
1009 		return;
1010 
1011 	cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1012 
1013 	present = snd_hda_codec_read(codec, spec->ext_mic.pin, 0,
1014 				     AC_VERB_GET_PIN_SENSE, 0);
1015 	present &= AC_PINSENSE_PRESENCE;
1016 	if (present) {
1017 		alive = &spec->ext_mic;
1018 		dead = &spec->int_mic;
1019 	} else {
1020 		alive = &spec->int_mic;
1021 		dead = &spec->ext_mic;
1022 	}
1023 
1024 	type = get_wcaps_type(get_wcaps(codec, cap_nid));
1025 	if (type == AC_WID_AUD_MIX) {
1026 		/* Matrix-mixer style (e.g. ALC882) */
1027 		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1028 					 alive->mux_idx,
1029 					 HDA_AMP_MUTE, 0);
1030 		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1031 					 dead->mux_idx,
1032 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
1033 	} else {
1034 		/* MUX style (e.g. ALC880) */
1035 		snd_hda_codec_write_cache(codec, cap_nid, 0,
1036 					  AC_VERB_SET_CONNECT_SEL,
1037 					  alive->mux_idx);
1038 	}
1039 
1040 	/* FIXME: analog mixer */
1041 }
1042 
1043 /* unsolicited event for HP jack sensing */
1044 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1045 {
1046 	if (codec->vendor_id == 0x10ec0880)
1047 		res >>= 28;
1048 	else
1049 		res >>= 26;
1050 	switch (res) {
1051 	case ALC880_HP_EVENT:
1052 		alc_automute_pin(codec);
1053 		break;
1054 	case ALC880_MIC_EVENT:
1055 		alc_mic_automute(codec);
1056 		break;
1057 	}
1058 }
1059 
1060 static void alc_inithook(struct hda_codec *codec)
1061 {
1062 	alc_automute_pin(codec);
1063 	alc_mic_automute(codec);
1064 }
1065 
1066 /* additional initialization for ALC888 variants */
1067 static void alc888_coef_init(struct hda_codec *codec)
1068 {
1069 	unsigned int tmp;
1070 
1071 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1072 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1073 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1074 	if ((tmp & 0xf0) == 0x20)
1075 		/* alc888S-VC */
1076 		snd_hda_codec_read(codec, 0x20, 0,
1077 				   AC_VERB_SET_PROC_COEF, 0x830);
1078 	 else
1079 		 /* alc888-VB */
1080 		 snd_hda_codec_read(codec, 0x20, 0,
1081 				    AC_VERB_SET_PROC_COEF, 0x3030);
1082 }
1083 
1084 static void alc889_coef_init(struct hda_codec *codec)
1085 {
1086 	unsigned int tmp;
1087 
1088 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1089 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1090 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1091 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1092 }
1093 
1094 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1095 {
1096 	unsigned int tmp;
1097 
1098 	switch (type) {
1099 	case ALC_INIT_GPIO1:
1100 		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1101 		break;
1102 	case ALC_INIT_GPIO2:
1103 		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1104 		break;
1105 	case ALC_INIT_GPIO3:
1106 		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1107 		break;
1108 	case ALC_INIT_DEFAULT:
1109 		switch (codec->vendor_id) {
1110 		case 0x10ec0260:
1111 			snd_hda_codec_write(codec, 0x0f, 0,
1112 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1113 			snd_hda_codec_write(codec, 0x10, 0,
1114 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1115 			break;
1116 		case 0x10ec0262:
1117 		case 0x10ec0267:
1118 		case 0x10ec0268:
1119 		case 0x10ec0269:
1120 		case 0x10ec0272:
1121 		case 0x10ec0660:
1122 		case 0x10ec0662:
1123 		case 0x10ec0663:
1124 		case 0x10ec0862:
1125 		case 0x10ec0889:
1126 			snd_hda_codec_write(codec, 0x14, 0,
1127 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1128 			snd_hda_codec_write(codec, 0x15, 0,
1129 					    AC_VERB_SET_EAPD_BTLENABLE, 2);
1130 			break;
1131 		}
1132 		switch (codec->vendor_id) {
1133 		case 0x10ec0260:
1134 			snd_hda_codec_write(codec, 0x1a, 0,
1135 					    AC_VERB_SET_COEF_INDEX, 7);
1136 			tmp = snd_hda_codec_read(codec, 0x1a, 0,
1137 						 AC_VERB_GET_PROC_COEF, 0);
1138 			snd_hda_codec_write(codec, 0x1a, 0,
1139 					    AC_VERB_SET_COEF_INDEX, 7);
1140 			snd_hda_codec_write(codec, 0x1a, 0,
1141 					    AC_VERB_SET_PROC_COEF,
1142 					    tmp | 0x2010);
1143 			break;
1144 		case 0x10ec0262:
1145 		case 0x10ec0880:
1146 		case 0x10ec0882:
1147 		case 0x10ec0883:
1148 		case 0x10ec0885:
1149 		case 0x10ec0887:
1150 		case 0x10ec0889:
1151 			alc889_coef_init(codec);
1152 			break;
1153 		case 0x10ec0888:
1154 			alc888_coef_init(codec);
1155 			break;
1156 		case 0x10ec0267:
1157 		case 0x10ec0268:
1158 			snd_hda_codec_write(codec, 0x20, 0,
1159 					    AC_VERB_SET_COEF_INDEX, 7);
1160 			tmp = snd_hda_codec_read(codec, 0x20, 0,
1161 						 AC_VERB_GET_PROC_COEF, 0);
1162 			snd_hda_codec_write(codec, 0x20, 0,
1163 					    AC_VERB_SET_COEF_INDEX, 7);
1164 			snd_hda_codec_write(codec, 0x20, 0,
1165 					    AC_VERB_SET_PROC_COEF,
1166 					    tmp | 0x3000);
1167 			break;
1168 		}
1169 		break;
1170 	}
1171 }
1172 
1173 static void alc_init_auto_hp(struct hda_codec *codec)
1174 {
1175 	struct alc_spec *spec = codec->spec;
1176 
1177 	if (!spec->autocfg.hp_pins[0])
1178 		return;
1179 
1180 	if (!spec->autocfg.speaker_pins[0]) {
1181 		if (spec->autocfg.line_out_pins[0] &&
1182 		    spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1183 			spec->autocfg.speaker_pins[0] =
1184 				spec->autocfg.line_out_pins[0];
1185 		else
1186 			return;
1187 	}
1188 
1189 	snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1190 		    spec->autocfg.hp_pins[0]);
1191 	snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1192 				  AC_VERB_SET_UNSOLICITED_ENABLE,
1193 				  AC_USRSP_EN | ALC880_HP_EVENT);
1194 	spec->unsol_event = alc_sku_unsol_event;
1195 }
1196 
1197 static void alc_init_auto_mic(struct hda_codec *codec)
1198 {
1199 	struct alc_spec *spec = codec->spec;
1200 	struct auto_pin_cfg *cfg = &spec->autocfg;
1201 	hda_nid_t fixed, ext;
1202 	int i;
1203 
1204 	/* there must be only two mic inputs exclusively */
1205 	for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1206 		if (cfg->input_pins[i])
1207 			return;
1208 
1209 	fixed = ext = 0;
1210 	for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1211 		hda_nid_t nid = cfg->input_pins[i];
1212 		unsigned int defcfg;
1213 		if (!nid)
1214 			return;
1215 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
1216 		switch (get_defcfg_connect(defcfg)) {
1217 		case AC_JACK_PORT_FIXED:
1218 			if (fixed)
1219 				return; /* already occupied */
1220 			fixed = nid;
1221 			break;
1222 		case AC_JACK_PORT_COMPLEX:
1223 			if (ext)
1224 				return; /* already occupied */
1225 			ext = nid;
1226 			break;
1227 		default:
1228 			return; /* invalid entry */
1229 		}
1230 	}
1231 	if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1232 		return; /* no unsol support */
1233 	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1234 		    ext, fixed);
1235 	spec->ext_mic.pin = ext;
1236 	spec->int_mic.pin = fixed;
1237 	spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1238 	spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1239 	spec->auto_mic = 1;
1240 	snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1241 				  AC_VERB_SET_UNSOLICITED_ENABLE,
1242 				  AC_USRSP_EN | ALC880_MIC_EVENT);
1243 	spec->unsol_event = alc_sku_unsol_event;
1244 }
1245 
1246 /* check subsystem ID and set up device-specific initialization;
1247  * return 1 if initialized, 0 if invalid SSID
1248  */
1249 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1250  *	31 ~ 16 :	Manufacture ID
1251  *	15 ~ 8	:	SKU ID
1252  *	7  ~ 0	:	Assembly ID
1253  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1254  */
1255 static int alc_subsystem_id(struct hda_codec *codec,
1256 			    hda_nid_t porta, hda_nid_t porte,
1257 			    hda_nid_t portd)
1258 {
1259 	unsigned int ass, tmp, i;
1260 	unsigned nid;
1261 	struct alc_spec *spec = codec->spec;
1262 
1263 	ass = codec->subsystem_id & 0xffff;
1264 	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1265 		goto do_sku;
1266 
1267 	/* invalid SSID, check the special NID pin defcfg instead */
1268 	/*
1269 	 * 31~30	: port connectivity
1270 	 * 29~21	: reserve
1271 	 * 20		: PCBEEP input
1272 	 * 19~16	: Check sum (15:1)
1273 	 * 15~1		: Custom
1274 	 * 0		: override
1275 	*/
1276 	nid = 0x1d;
1277 	if (codec->vendor_id == 0x10ec0260)
1278 		nid = 0x17;
1279 	ass = snd_hda_codec_get_pincfg(codec, nid);
1280 	snd_printd("realtek: No valid SSID, "
1281 		   "checking pincfg 0x%08x for NID 0x%x\n",
1282 		   ass, nid);
1283 	if (!(ass & 1) && !(ass & 0x100000))
1284 		return 0;
1285 	if ((ass >> 30) != 1)	/* no physical connection */
1286 		return 0;
1287 
1288 	/* check sum */
1289 	tmp = 0;
1290 	for (i = 1; i < 16; i++) {
1291 		if ((ass >> i) & 1)
1292 			tmp++;
1293 	}
1294 	if (((ass >> 16) & 0xf) != tmp)
1295 		return 0;
1296 do_sku:
1297 	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1298 		   ass & 0xffff, codec->vendor_id);
1299 	/*
1300 	 * 0 : override
1301 	 * 1 :	Swap Jack
1302 	 * 2 : 0 --> Desktop, 1 --> Laptop
1303 	 * 3~5 : External Amplifier control
1304 	 * 7~6 : Reserved
1305 	*/
1306 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
1307 	switch (tmp) {
1308 	case 1:
1309 		spec->init_amp = ALC_INIT_GPIO1;
1310 		break;
1311 	case 3:
1312 		spec->init_amp = ALC_INIT_GPIO2;
1313 		break;
1314 	case 7:
1315 		spec->init_amp = ALC_INIT_GPIO3;
1316 		break;
1317 	case 5:
1318 		spec->init_amp = ALC_INIT_DEFAULT;
1319 		break;
1320 	}
1321 
1322 	/* is laptop or Desktop and enable the function "Mute internal speaker
1323 	 * when the external headphone out jack is plugged"
1324 	 */
1325 	if (!(ass & 0x8000))
1326 		return 1;
1327 	/*
1328 	 * 10~8 : Jack location
1329 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1330 	 * 14~13: Resvered
1331 	 * 15   : 1 --> enable the function "Mute internal speaker
1332 	 *	        when the external headphone out jack is plugged"
1333 	 */
1334 	if (!spec->autocfg.hp_pins[0]) {
1335 		hda_nid_t nid;
1336 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
1337 		if (tmp == 0)
1338 			nid = porta;
1339 		else if (tmp == 1)
1340 			nid = porte;
1341 		else if (tmp == 2)
1342 			nid = portd;
1343 		else
1344 			return 1;
1345 		for (i = 0; i < spec->autocfg.line_outs; i++)
1346 			if (spec->autocfg.line_out_pins[i] == nid)
1347 				return 1;
1348 		spec->autocfg.hp_pins[0] = nid;
1349 	}
1350 
1351 	alc_init_auto_hp(codec);
1352 	alc_init_auto_mic(codec);
1353 	return 1;
1354 }
1355 
1356 static void alc_ssid_check(struct hda_codec *codec,
1357 			   hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1358 {
1359 	if (!alc_subsystem_id(codec, porta, porte, portd)) {
1360 		struct alc_spec *spec = codec->spec;
1361 		snd_printd("realtek: "
1362 			   "Enable default setup for auto mode as fallback\n");
1363 		spec->init_amp = ALC_INIT_DEFAULT;
1364 		alc_init_auto_hp(codec);
1365 		alc_init_auto_mic(codec);
1366 	}
1367 }
1368 
1369 /*
1370  * Fix-up pin default configurations and add default verbs
1371  */
1372 
1373 struct alc_pincfg {
1374 	hda_nid_t nid;
1375 	u32 val;
1376 };
1377 
1378 struct alc_fixup {
1379 	const struct alc_pincfg *pins;
1380 	const struct hda_verb *verbs;
1381 };
1382 
1383 static void alc_pick_fixup(struct hda_codec *codec,
1384 			   const struct snd_pci_quirk *quirk,
1385 			   const struct alc_fixup *fix)
1386 {
1387 	const struct alc_pincfg *cfg;
1388 
1389 	quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1390 	if (!quirk)
1391 		return;
1392 
1393 	fix += quirk->value;
1394 	cfg = fix->pins;
1395 	if (cfg) {
1396 		for (; cfg->nid; cfg++)
1397 			snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1398 	}
1399 	if (fix->verbs)
1400 		add_verb(codec->spec, fix->verbs);
1401 }
1402 
1403 /*
1404  * ALC888
1405  */
1406 
1407 /*
1408  * 2ch mode
1409  */
1410 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1411 /* Mic-in jack as mic in */
1412 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1413 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1414 /* Line-in jack as Line in */
1415 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1416 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1417 /* Line-Out as Front */
1418 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1419 	{ } /* end */
1420 };
1421 
1422 /*
1423  * 4ch mode
1424  */
1425 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1426 /* Mic-in jack as mic in */
1427 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1428 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1429 /* Line-in jack as Surround */
1430 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1431 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1432 /* Line-Out as Front */
1433 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1434 	{ } /* end */
1435 };
1436 
1437 /*
1438  * 6ch mode
1439  */
1440 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1441 /* Mic-in jack as CLFE */
1442 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1443 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1444 /* Line-in jack as Surround */
1445 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1446 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1447 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1448 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1449 	{ } /* end */
1450 };
1451 
1452 /*
1453  * 8ch mode
1454  */
1455 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1456 /* Mic-in jack as CLFE */
1457 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1458 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1459 /* Line-in jack as Surround */
1460 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1461 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1462 /* Line-Out as Side */
1463 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1464 	{ } /* end */
1465 };
1466 
1467 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1468 	{ 2, alc888_4ST_ch2_intel_init },
1469 	{ 4, alc888_4ST_ch4_intel_init },
1470 	{ 6, alc888_4ST_ch6_intel_init },
1471 	{ 8, alc888_4ST_ch8_intel_init },
1472 };
1473 
1474 /*
1475  * ALC888 Fujitsu Siemens Amillo xa3530
1476  */
1477 
1478 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1479 /* Front Mic: set to PIN_IN (empty by default) */
1480 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1481 /* Connect Internal HP to Front */
1482 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1483 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1484 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1485 /* Connect Bass HP to Front */
1486 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1487 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1488 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1489 /* Connect Line-Out side jack (SPDIF) to Side */
1490 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1491 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1492 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1493 /* Connect Mic jack to CLFE */
1494 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1495 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1496 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1497 /* Connect Line-in jack to Surround */
1498 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1499 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1500 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1501 /* Connect HP out jack to Front */
1502 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1503 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1504 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1505 /* Enable unsolicited event for HP jack and Line-out jack */
1506 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1507 	{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1508 	{}
1509 };
1510 
1511 static void alc_automute_amp(struct hda_codec *codec)
1512 {
1513 	struct alc_spec *spec = codec->spec;
1514 	unsigned int val, mute, pincap;
1515 	hda_nid_t nid;
1516 	int i;
1517 
1518 	spec->jack_present = 0;
1519 	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1520 		nid = spec->autocfg.hp_pins[i];
1521 		if (!nid)
1522 			break;
1523 		pincap = snd_hda_query_pin_caps(codec, nid);
1524 		if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1525 			snd_hda_codec_read(codec, nid, 0,
1526 					   AC_VERB_SET_PIN_SENSE, 0);
1527 		val = snd_hda_codec_read(codec, nid, 0,
1528 					 AC_VERB_GET_PIN_SENSE, 0);
1529 		if (val & AC_PINSENSE_PRESENCE) {
1530 			spec->jack_present = 1;
1531 			break;
1532 		}
1533 	}
1534 
1535 	mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1536 	/* Toggle internal speakers muting */
1537 	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1538 		nid = spec->autocfg.speaker_pins[i];
1539 		if (!nid)
1540 			break;
1541 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1542 					 HDA_AMP_MUTE, mute);
1543 	}
1544 }
1545 
1546 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1547 					 unsigned int res)
1548 {
1549 	if (codec->vendor_id == 0x10ec0880)
1550 		res >>= 28;
1551 	else
1552 		res >>= 26;
1553 	if (res == ALC880_HP_EVENT)
1554 		alc_automute_amp(codec);
1555 }
1556 
1557 static void alc889_automute_setup(struct hda_codec *codec)
1558 {
1559 	struct alc_spec *spec = codec->spec;
1560 
1561 	spec->autocfg.hp_pins[0] = 0x15;
1562 	spec->autocfg.speaker_pins[0] = 0x14;
1563 	spec->autocfg.speaker_pins[1] = 0x16;
1564 	spec->autocfg.speaker_pins[2] = 0x17;
1565 	spec->autocfg.speaker_pins[3] = 0x19;
1566 	spec->autocfg.speaker_pins[4] = 0x1a;
1567 }
1568 
1569 static void alc889_intel_init_hook(struct hda_codec *codec)
1570 {
1571 	alc889_coef_init(codec);
1572 	alc_automute_amp(codec);
1573 }
1574 
1575 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1576 {
1577 	struct alc_spec *spec = codec->spec;
1578 
1579 	spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1580 	spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1581 	spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1582 	spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1583 }
1584 
1585 /*
1586  * ALC888 Acer Aspire 4930G model
1587  */
1588 
1589 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1590 /* Front Mic: set to PIN_IN (empty by default) */
1591 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1592 /* Unselect Front Mic by default in input mixer 3 */
1593 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1594 /* Enable unsolicited event for HP jack */
1595 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1596 /* Connect Internal HP to front */
1597 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1598 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1599 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1600 /* Connect HP out to front */
1601 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1602 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1603 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1604 	{ }
1605 };
1606 
1607 /*
1608  * ALC888 Acer Aspire 6530G model
1609  */
1610 
1611 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1612 /* Bias voltage on for external mic port */
1613 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1614 /* Front Mic: set to PIN_IN (empty by default) */
1615 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1616 /* Unselect Front Mic by default in input mixer 3 */
1617 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1618 /* Enable unsolicited event for HP jack */
1619 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1620 /* Enable speaker output */
1621 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1622 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1623 /* Enable headphone output */
1624 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1625 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1626 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1627 	{ }
1628 };
1629 
1630 /*
1631  * ALC889 Acer Aspire 8930G model
1632  */
1633 
1634 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1635 /* Front Mic: set to PIN_IN (empty by default) */
1636 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1637 /* Unselect Front Mic by default in input mixer 3 */
1638 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1639 /* Enable unsolicited event for HP jack */
1640 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1641 /* Connect Internal Front to Front */
1642 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1643 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1644 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1645 /* Connect Internal Rear to Rear */
1646 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1647 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1648 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1649 /* Connect Internal CLFE to CLFE */
1650 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1651 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1652 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1653 /* Connect HP out to Front */
1654 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1655 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1656 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1657 /* Enable all DACs */
1658 /*  DAC DISABLE/MUTE 1? */
1659 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1660 	{0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1661 	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1662 /*  DAC DISABLE/MUTE 2? */
1663 /*  some bit here disables the other DACs. Init=0x4900 */
1664 	{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1665 	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1666 /* Enable amplifiers */
1667 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1668 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1669 /* DMIC fix
1670  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1671  * which makes the stereo useless. However, either the mic or the ALC889
1672  * makes the signal become a difference/sum signal instead of standard
1673  * stereo, which is annoying. So instead we flip this bit which makes the
1674  * codec replicate the sum signal to both channels, turning it into a
1675  * normal mono mic.
1676  */
1677 /*  DMIC_CONTROL? Init value = 0x0001 */
1678 	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1679 	{0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1680 	{ }
1681 };
1682 
1683 static struct hda_input_mux alc888_2_capture_sources[2] = {
1684 	/* Front mic only available on one ADC */
1685 	{
1686 		.num_items = 4,
1687 		.items = {
1688 			{ "Mic", 0x0 },
1689 			{ "Line", 0x2 },
1690 			{ "CD", 0x4 },
1691 			{ "Front Mic", 0xb },
1692 		},
1693 	},
1694 	{
1695 		.num_items = 3,
1696 		.items = {
1697 			{ "Mic", 0x0 },
1698 			{ "Line", 0x2 },
1699 			{ "CD", 0x4 },
1700 		},
1701 	}
1702 };
1703 
1704 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1705 	/* Interal mic only available on one ADC */
1706 	{
1707 		.num_items = 5,
1708 		.items = {
1709 			{ "Ext Mic", 0x0 },
1710 			{ "Line In", 0x2 },
1711 			{ "CD", 0x4 },
1712 			{ "Input Mix", 0xa },
1713 			{ "Int Mic", 0xb },
1714 		},
1715 	},
1716 	{
1717 		.num_items = 4,
1718 		.items = {
1719 			{ "Ext Mic", 0x0 },
1720 			{ "Line In", 0x2 },
1721 			{ "CD", 0x4 },
1722 			{ "Input Mix", 0xa },
1723 		},
1724 	}
1725 };
1726 
1727 static struct hda_input_mux alc889_capture_sources[3] = {
1728 	/* Digital mic only available on first "ADC" */
1729 	{
1730 		.num_items = 5,
1731 		.items = {
1732 			{ "Mic", 0x0 },
1733 			{ "Line", 0x2 },
1734 			{ "CD", 0x4 },
1735 			{ "Front Mic", 0xb },
1736 			{ "Input Mix", 0xa },
1737 		},
1738 	},
1739 	{
1740 		.num_items = 4,
1741 		.items = {
1742 			{ "Mic", 0x0 },
1743 			{ "Line", 0x2 },
1744 			{ "CD", 0x4 },
1745 			{ "Input Mix", 0xa },
1746 		},
1747 	},
1748 	{
1749 		.num_items = 4,
1750 		.items = {
1751 			{ "Mic", 0x0 },
1752 			{ "Line", 0x2 },
1753 			{ "CD", 0x4 },
1754 			{ "Input Mix", 0xa },
1755 		},
1756 	}
1757 };
1758 
1759 static struct snd_kcontrol_new alc888_base_mixer[] = {
1760 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1761 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1762 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1763 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1764 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1765 		HDA_OUTPUT),
1766 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1767 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1768 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1769 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1770 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1771 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1772 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1773 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1774 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1775 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1776 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1777 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1778 	{ } /* end */
1779 };
1780 
1781 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1782 {
1783 	struct alc_spec *spec = codec->spec;
1784 
1785 	spec->autocfg.hp_pins[0] = 0x15;
1786 	spec->autocfg.speaker_pins[0] = 0x14;
1787 }
1788 
1789 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1790 {
1791 	struct alc_spec *spec = codec->spec;
1792 
1793 	spec->autocfg.hp_pins[0] = 0x15;
1794 	spec->autocfg.speaker_pins[0] = 0x14;
1795 	spec->autocfg.speaker_pins[1] = 0x16;
1796 	spec->autocfg.speaker_pins[2] = 0x17;
1797 }
1798 
1799 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1800 {
1801 	struct alc_spec *spec = codec->spec;
1802 
1803 	spec->autocfg.hp_pins[0] = 0x15;
1804 	spec->autocfg.speaker_pins[0] = 0x14;
1805 	spec->autocfg.speaker_pins[1] = 0x16;
1806 	spec->autocfg.speaker_pins[2] = 0x1b;
1807 }
1808 
1809 /*
1810  * ALC880 3-stack model
1811  *
1812  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1813  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1814  *                 F-Mic = 0x1b, HP = 0x19
1815  */
1816 
1817 static hda_nid_t alc880_dac_nids[4] = {
1818 	/* front, rear, clfe, rear_surr */
1819 	0x02, 0x05, 0x04, 0x03
1820 };
1821 
1822 static hda_nid_t alc880_adc_nids[3] = {
1823 	/* ADC0-2 */
1824 	0x07, 0x08, 0x09,
1825 };
1826 
1827 /* The datasheet says the node 0x07 is connected from inputs,
1828  * but it shows zero connection in the real implementation on some devices.
1829  * Note: this is a 915GAV bug, fixed on 915GLV
1830  */
1831 static hda_nid_t alc880_adc_nids_alt[2] = {
1832 	/* ADC1-2 */
1833 	0x08, 0x09,
1834 };
1835 
1836 #define ALC880_DIGOUT_NID	0x06
1837 #define ALC880_DIGIN_NID	0x0a
1838 
1839 static struct hda_input_mux alc880_capture_source = {
1840 	.num_items = 4,
1841 	.items = {
1842 		{ "Mic", 0x0 },
1843 		{ "Front Mic", 0x3 },
1844 		{ "Line", 0x2 },
1845 		{ "CD", 0x4 },
1846 	},
1847 };
1848 
1849 /* channel source setting (2/6 channel selection for 3-stack) */
1850 /* 2ch mode */
1851 static struct hda_verb alc880_threestack_ch2_init[] = {
1852 	/* set line-in to input, mute it */
1853 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1854 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1855 	/* set mic-in to input vref 80%, mute it */
1856 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1857 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1858 	{ } /* end */
1859 };
1860 
1861 /* 6ch mode */
1862 static struct hda_verb alc880_threestack_ch6_init[] = {
1863 	/* set line-in to output, unmute it */
1864 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1865 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1866 	/* set mic-in to output, unmute it */
1867 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1868 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1869 	{ } /* end */
1870 };
1871 
1872 static struct hda_channel_mode alc880_threestack_modes[2] = {
1873 	{ 2, alc880_threestack_ch2_init },
1874 	{ 6, alc880_threestack_ch6_init },
1875 };
1876 
1877 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1878 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1879 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1880 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1881 	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1882 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1883 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1884 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1885 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1886 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1887 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1888 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1889 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1890 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1891 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1892 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1893 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1894 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1895 	{
1896 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1897 		.name = "Channel Mode",
1898 		.info = alc_ch_mode_info,
1899 		.get = alc_ch_mode_get,
1900 		.put = alc_ch_mode_put,
1901 	},
1902 	{ } /* end */
1903 };
1904 
1905 /* capture mixer elements */
1906 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1907 			    struct snd_ctl_elem_info *uinfo)
1908 {
1909 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1910 	struct alc_spec *spec = codec->spec;
1911 	int err;
1912 
1913 	mutex_lock(&codec->control_mutex);
1914 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1915 						      HDA_INPUT);
1916 	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1917 	mutex_unlock(&codec->control_mutex);
1918 	return err;
1919 }
1920 
1921 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1922 			   unsigned int size, unsigned int __user *tlv)
1923 {
1924 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1925 	struct alc_spec *spec = codec->spec;
1926 	int err;
1927 
1928 	mutex_lock(&codec->control_mutex);
1929 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1930 						      HDA_INPUT);
1931 	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1932 	mutex_unlock(&codec->control_mutex);
1933 	return err;
1934 }
1935 
1936 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1937 			     struct snd_ctl_elem_value *ucontrol);
1938 
1939 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1940 				 struct snd_ctl_elem_value *ucontrol,
1941 				 getput_call_t func)
1942 {
1943 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1944 	struct alc_spec *spec = codec->spec;
1945 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1946 	int err;
1947 
1948 	mutex_lock(&codec->control_mutex);
1949 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1950 						      3, 0, HDA_INPUT);
1951 	err = func(kcontrol, ucontrol);
1952 	mutex_unlock(&codec->control_mutex);
1953 	return err;
1954 }
1955 
1956 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1957 			   struct snd_ctl_elem_value *ucontrol)
1958 {
1959 	return alc_cap_getput_caller(kcontrol, ucontrol,
1960 				     snd_hda_mixer_amp_volume_get);
1961 }
1962 
1963 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1964 			   struct snd_ctl_elem_value *ucontrol)
1965 {
1966 	return alc_cap_getput_caller(kcontrol, ucontrol,
1967 				     snd_hda_mixer_amp_volume_put);
1968 }
1969 
1970 /* capture mixer elements */
1971 #define alc_cap_sw_info		snd_ctl_boolean_stereo_info
1972 
1973 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1974 			  struct snd_ctl_elem_value *ucontrol)
1975 {
1976 	return alc_cap_getput_caller(kcontrol, ucontrol,
1977 				     snd_hda_mixer_amp_switch_get);
1978 }
1979 
1980 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1981 			  struct snd_ctl_elem_value *ucontrol)
1982 {
1983 	return alc_cap_getput_caller(kcontrol, ucontrol,
1984 				     snd_hda_mixer_amp_switch_put);
1985 }
1986 
1987 #define _DEFINE_CAPMIX(num) \
1988 	{ \
1989 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1990 		.name = "Capture Switch", \
1991 		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1992 		.count = num, \
1993 		.info = alc_cap_sw_info, \
1994 		.get = alc_cap_sw_get, \
1995 		.put = alc_cap_sw_put, \
1996 	}, \
1997 	{ \
1998 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1999 		.name = "Capture Volume", \
2000 		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2001 			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2002 			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2003 		.count = num, \
2004 		.info = alc_cap_vol_info, \
2005 		.get = alc_cap_vol_get, \
2006 		.put = alc_cap_vol_put, \
2007 		.tlv = { .c = alc_cap_vol_tlv }, \
2008 	}
2009 
2010 #define _DEFINE_CAPSRC(num) \
2011 	{ \
2012 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2013 		/* .name = "Capture Source", */ \
2014 		.name = "Input Source", \
2015 		.count = num, \
2016 		.info = alc_mux_enum_info, \
2017 		.get = alc_mux_enum_get, \
2018 		.put = alc_mux_enum_put, \
2019 	}
2020 
2021 #define DEFINE_CAPMIX(num) \
2022 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2023 	_DEFINE_CAPMIX(num),				      \
2024 	_DEFINE_CAPSRC(num),				      \
2025 	{ } /* end */					      \
2026 }
2027 
2028 #define DEFINE_CAPMIX_NOSRC(num) \
2029 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2030 	_DEFINE_CAPMIX(num),					    \
2031 	{ } /* end */						    \
2032 }
2033 
2034 /* up to three ADCs */
2035 DEFINE_CAPMIX(1);
2036 DEFINE_CAPMIX(2);
2037 DEFINE_CAPMIX(3);
2038 DEFINE_CAPMIX_NOSRC(1);
2039 DEFINE_CAPMIX_NOSRC(2);
2040 DEFINE_CAPMIX_NOSRC(3);
2041 
2042 /*
2043  * ALC880 5-stack model
2044  *
2045  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2046  *      Side = 0x02 (0xd)
2047  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2048  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2049  */
2050 
2051 /* additional mixers to alc880_three_stack_mixer */
2052 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2053 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2054 	HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2055 	{ } /* end */
2056 };
2057 
2058 /* channel source setting (6/8 channel selection for 5-stack) */
2059 /* 6ch mode */
2060 static struct hda_verb alc880_fivestack_ch6_init[] = {
2061 	/* set line-in to input, mute it */
2062 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2063 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2064 	{ } /* end */
2065 };
2066 
2067 /* 8ch mode */
2068 static struct hda_verb alc880_fivestack_ch8_init[] = {
2069 	/* set line-in to output, unmute it */
2070 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2071 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2072 	{ } /* end */
2073 };
2074 
2075 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2076 	{ 6, alc880_fivestack_ch6_init },
2077 	{ 8, alc880_fivestack_ch8_init },
2078 };
2079 
2080 
2081 /*
2082  * ALC880 6-stack model
2083  *
2084  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2085  *      Side = 0x05 (0x0f)
2086  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2087  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2088  */
2089 
2090 static hda_nid_t alc880_6st_dac_nids[4] = {
2091 	/* front, rear, clfe, rear_surr */
2092 	0x02, 0x03, 0x04, 0x05
2093 };
2094 
2095 static struct hda_input_mux alc880_6stack_capture_source = {
2096 	.num_items = 4,
2097 	.items = {
2098 		{ "Mic", 0x0 },
2099 		{ "Front Mic", 0x1 },
2100 		{ "Line", 0x2 },
2101 		{ "CD", 0x4 },
2102 	},
2103 };
2104 
2105 /* fixed 8-channels */
2106 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2107 	{ 8, NULL },
2108 };
2109 
2110 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2111 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2112 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2113 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2114 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2115 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2116 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2117 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2118 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2119 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2120 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2121 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2122 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2123 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2124 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2125 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2126 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2127 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2128 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2129 	{
2130 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2131 		.name = "Channel Mode",
2132 		.info = alc_ch_mode_info,
2133 		.get = alc_ch_mode_get,
2134 		.put = alc_ch_mode_put,
2135 	},
2136 	{ } /* end */
2137 };
2138 
2139 
2140 /*
2141  * ALC880 W810 model
2142  *
2143  * W810 has rear IO for:
2144  * Front (DAC 02)
2145  * Surround (DAC 03)
2146  * Center/LFE (DAC 04)
2147  * Digital out (06)
2148  *
2149  * The system also has a pair of internal speakers, and a headphone jack.
2150  * These are both connected to Line2 on the codec, hence to DAC 02.
2151  *
2152  * There is a variable resistor to control the speaker or headphone
2153  * volume. This is a hardware-only device without a software API.
2154  *
2155  * Plugging headphones in will disable the internal speakers. This is
2156  * implemented in hardware, not via the driver using jack sense. In
2157  * a similar fashion, plugging into the rear socket marked "front" will
2158  * disable both the speakers and headphones.
2159  *
2160  * For input, there's a microphone jack, and an "audio in" jack.
2161  * These may not do anything useful with this driver yet, because I
2162  * haven't setup any initialization verbs for these yet...
2163  */
2164 
2165 static hda_nid_t alc880_w810_dac_nids[3] = {
2166 	/* front, rear/surround, clfe */
2167 	0x02, 0x03, 0x04
2168 };
2169 
2170 /* fixed 6 channels */
2171 static struct hda_channel_mode alc880_w810_modes[1] = {
2172 	{ 6, NULL }
2173 };
2174 
2175 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2176 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2177 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2178 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2179 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2180 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2181 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2182 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2183 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2184 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2185 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2186 	{ } /* end */
2187 };
2188 
2189 
2190 /*
2191  * Z710V model
2192  *
2193  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2194  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2195  *                 Line = 0x1a
2196  */
2197 
2198 static hda_nid_t alc880_z71v_dac_nids[1] = {
2199 	0x02
2200 };
2201 #define ALC880_Z71V_HP_DAC	0x03
2202 
2203 /* fixed 2 channels */
2204 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2205 	{ 2, NULL }
2206 };
2207 
2208 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2209 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2210 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2211 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2212 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2213 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2214 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2215 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2216 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2217 	{ } /* end */
2218 };
2219 
2220 
2221 /*
2222  * ALC880 F1734 model
2223  *
2224  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2225  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2226  */
2227 
2228 static hda_nid_t alc880_f1734_dac_nids[1] = {
2229 	0x03
2230 };
2231 #define ALC880_F1734_HP_DAC	0x02
2232 
2233 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2234 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2235 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2236 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2237 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2238 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2239 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2240 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2241 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2242 	{ } /* end */
2243 };
2244 
2245 static struct hda_input_mux alc880_f1734_capture_source = {
2246 	.num_items = 2,
2247 	.items = {
2248 		{ "Mic", 0x1 },
2249 		{ "CD", 0x4 },
2250 	},
2251 };
2252 
2253 
2254 /*
2255  * ALC880 ASUS model
2256  *
2257  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2258  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2259  *  Mic = 0x18, Line = 0x1a
2260  */
2261 
2262 #define alc880_asus_dac_nids	alc880_w810_dac_nids	/* identical with w810 */
2263 #define alc880_asus_modes	alc880_threestack_modes	/* 2/6 channel mode */
2264 
2265 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2266 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2267 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2268 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2269 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2270 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2271 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2272 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2273 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2274 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2275 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2276 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2277 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2278 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2279 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2280 	{
2281 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2282 		.name = "Channel Mode",
2283 		.info = alc_ch_mode_info,
2284 		.get = alc_ch_mode_get,
2285 		.put = alc_ch_mode_put,
2286 	},
2287 	{ } /* end */
2288 };
2289 
2290 /*
2291  * ALC880 ASUS W1V model
2292  *
2293  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2294  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2295  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2296  */
2297 
2298 /* additional mixers to alc880_asus_mixer */
2299 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2300 	HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2301 	HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2302 	{ } /* end */
2303 };
2304 
2305 /* TCL S700 */
2306 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2307 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2308 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2309 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2310 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2311 	HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2312 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2313 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2314 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2315 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2316 	{ } /* end */
2317 };
2318 
2319 /* Uniwill */
2320 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2321 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2322 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2323 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2324 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2325 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2326 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2327 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2328 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2329 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2330 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2331 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2332 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2333 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2334 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2335 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2336 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2337 	{
2338 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2339 		.name = "Channel Mode",
2340 		.info = alc_ch_mode_info,
2341 		.get = alc_ch_mode_get,
2342 		.put = alc_ch_mode_put,
2343 	},
2344 	{ } /* end */
2345 };
2346 
2347 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2348 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2349 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2350 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2351 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2352 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2353 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2354 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2355 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2356 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2357 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2358 	{ } /* end */
2359 };
2360 
2361 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2362 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2363 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2364 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2365 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2366 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2367 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2368 	{ } /* end */
2369 };
2370 
2371 /*
2372  * virtual master controls
2373  */
2374 
2375 /*
2376  * slave controls for virtual master
2377  */
2378 static const char *alc_slave_vols[] = {
2379 	"Front Playback Volume",
2380 	"Surround Playback Volume",
2381 	"Center Playback Volume",
2382 	"LFE Playback Volume",
2383 	"Side Playback Volume",
2384 	"Headphone Playback Volume",
2385 	"Speaker Playback Volume",
2386 	"Mono Playback Volume",
2387 	"Line-Out Playback Volume",
2388 	"PCM Playback Volume",
2389 	NULL,
2390 };
2391 
2392 static const char *alc_slave_sws[] = {
2393 	"Front Playback Switch",
2394 	"Surround Playback Switch",
2395 	"Center Playback Switch",
2396 	"LFE Playback Switch",
2397 	"Side Playback Switch",
2398 	"Headphone Playback Switch",
2399 	"Speaker Playback Switch",
2400 	"Mono Playback Switch",
2401 	"IEC958 Playback Switch",
2402 	NULL,
2403 };
2404 
2405 /*
2406  * build control elements
2407  */
2408 
2409 static void alc_free_kctls(struct hda_codec *codec);
2410 
2411 /* additional beep mixers; the actual parameters are overwritten at build */
2412 static struct snd_kcontrol_new alc_beep_mixer[] = {
2413 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2414 	HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2415 	{ } /* end */
2416 };
2417 
2418 static int alc_build_controls(struct hda_codec *codec)
2419 {
2420 	struct alc_spec *spec = codec->spec;
2421 	int err;
2422 	int i;
2423 
2424 	for (i = 0; i < spec->num_mixers; i++) {
2425 		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2426 		if (err < 0)
2427 			return err;
2428 	}
2429 	if (spec->cap_mixer) {
2430 		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2431 		if (err < 0)
2432 			return err;
2433 	}
2434 	if (spec->multiout.dig_out_nid) {
2435 		err = snd_hda_create_spdif_out_ctls(codec,
2436 						    spec->multiout.dig_out_nid);
2437 		if (err < 0)
2438 			return err;
2439 		if (!spec->no_analog) {
2440 			err = snd_hda_create_spdif_share_sw(codec,
2441 							    &spec->multiout);
2442 			if (err < 0)
2443 				return err;
2444 			spec->multiout.share_spdif = 1;
2445 		}
2446 	}
2447 	if (spec->dig_in_nid) {
2448 		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2449 		if (err < 0)
2450 			return err;
2451 	}
2452 
2453 	/* create beep controls if needed */
2454 	if (spec->beep_amp) {
2455 		struct snd_kcontrol_new *knew;
2456 		for (knew = alc_beep_mixer; knew->name; knew++) {
2457 			struct snd_kcontrol *kctl;
2458 			kctl = snd_ctl_new1(knew, codec);
2459 			if (!kctl)
2460 				return -ENOMEM;
2461 			kctl->private_value = spec->beep_amp;
2462 			err = snd_hda_ctl_add(codec, kctl);
2463 			if (err < 0)
2464 				return err;
2465 		}
2466 	}
2467 
2468 	/* if we have no master control, let's create it */
2469 	if (!spec->no_analog &&
2470 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2471 		unsigned int vmaster_tlv[4];
2472 		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2473 					HDA_OUTPUT, vmaster_tlv);
2474 		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2475 					  vmaster_tlv, alc_slave_vols);
2476 		if (err < 0)
2477 			return err;
2478 	}
2479 	if (!spec->no_analog &&
2480 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2481 		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2482 					  NULL, alc_slave_sws);
2483 		if (err < 0)
2484 			return err;
2485 	}
2486 
2487 	alc_free_kctls(codec); /* no longer needed */
2488 	return 0;
2489 }
2490 
2491 
2492 /*
2493  * initialize the codec volumes, etc
2494  */
2495 
2496 /*
2497  * generic initialization of ADC, input mixers and output mixers
2498  */
2499 static struct hda_verb alc880_volume_init_verbs[] = {
2500 	/*
2501 	 * Unmute ADC0-2 and set the default input to mic-in
2502 	 */
2503 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2504 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2505 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2506 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2507 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2508 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2509 
2510 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2511 	 * mixer widget
2512 	 * Note: PASD motherboards uses the Line In 2 as the input for front
2513 	 * panel mic (mic 2)
2514 	 */
2515 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2516 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2517 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2518 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2519 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2520 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2521 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2522 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2523 
2524 	/*
2525 	 * Set up output mixers (0x0c - 0x0f)
2526 	 */
2527 	/* set vol=0 to output mixers */
2528 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2529 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2530 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2531 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2532 	/* set up input amps for analog loopback */
2533 	/* Amp Indices: DAC = 0, mixer = 1 */
2534 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2535 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2536 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2537 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2538 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2539 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2540 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2541 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2542 
2543 	{ }
2544 };
2545 
2546 /*
2547  * 3-stack pin configuration:
2548  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2549  */
2550 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2551 	/*
2552 	 * preset connection lists of input pins
2553 	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2554 	 */
2555 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2556 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2557 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2558 
2559 	/*
2560 	 * Set pin mode and muting
2561 	 */
2562 	/* set front pin widgets 0x14 for output */
2563 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2564 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2565 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2566 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2567 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2568 	/* Mic2 (as headphone out) for HP output */
2569 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2570 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2571 	/* Line In pin widget for input */
2572 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2573 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2574 	/* Line2 (as front mic) pin widget for input and vref at 80% */
2575 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2576 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2577 	/* CD pin widget for input */
2578 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2579 
2580 	{ }
2581 };
2582 
2583 /*
2584  * 5-stack pin configuration:
2585  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2586  * line-in/side = 0x1a, f-mic = 0x1b
2587  */
2588 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2589 	/*
2590 	 * preset connection lists of input pins
2591 	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2592 	 */
2593 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2594 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2595 
2596 	/*
2597 	 * Set pin mode and muting
2598 	 */
2599 	/* set pin widgets 0x14-0x17 for output */
2600 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2601 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2602 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2603 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2604 	/* unmute pins for output (no gain on this amp) */
2605 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2606 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2608 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2609 
2610 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2611 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2612 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2613 	/* Mic2 (as headphone out) for HP output */
2614 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2615 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2616 	/* Line In pin widget for input */
2617 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2618 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2619 	/* Line2 (as front mic) pin widget for input and vref at 80% */
2620 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2621 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2622 	/* CD pin widget for input */
2623 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2624 
2625 	{ }
2626 };
2627 
2628 /*
2629  * W810 pin configuration:
2630  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2631  */
2632 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2633 	/* hphone/speaker input selector: front DAC */
2634 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2635 
2636 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2637 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2638 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2639 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2640 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2641 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2642 
2643 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2644 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2645 
2646 	{ }
2647 };
2648 
2649 /*
2650  * Z71V pin configuration:
2651  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2652  */
2653 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2654 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2655 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2656 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2657 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2658 
2659 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2660 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2661 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2662 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2663 
2664 	{ }
2665 };
2666 
2667 /*
2668  * 6-stack pin configuration:
2669  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2670  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2671  */
2672 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2673 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2674 
2675 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2676 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2677 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2678 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2679 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2680 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2681 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2682 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2683 
2684 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2685 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2686 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2687 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2688 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2689 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2690 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2691 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2692 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2693 
2694 	{ }
2695 };
2696 
2697 /*
2698  * Uniwill pin configuration:
2699  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2700  * line = 0x1a
2701  */
2702 static struct hda_verb alc880_uniwill_init_verbs[] = {
2703 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2704 
2705 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2706 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2707 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2708 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2709 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2710 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2711 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2712 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2713 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2714 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2715 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2716 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2717 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2718 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2719 
2720 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2721 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2722 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2723 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2724 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2725 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2726 	/* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2727 	/* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2728 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2729 
2730 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2731 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2732 
2733 	{ }
2734 };
2735 
2736 /*
2737 * Uniwill P53
2738 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2739  */
2740 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2741 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2742 
2743 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2744 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2745 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2746 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2747 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2748 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2749 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2750 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2751 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2752 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2753 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2754 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2755 
2756 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2757 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2758 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2759 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2760 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2761 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2762 
2763 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2764 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2765 
2766 	{ }
2767 };
2768 
2769 static struct hda_verb alc880_beep_init_verbs[] = {
2770 	{ 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2771 	{ }
2772 };
2773 
2774 /* auto-toggle front mic */
2775 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2776 {
2777  	unsigned int present;
2778 	unsigned char bits;
2779 
2780 	present = snd_hda_codec_read(codec, 0x18, 0,
2781 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2782 	bits = present ? HDA_AMP_MUTE : 0;
2783 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2784 }
2785 
2786 static void alc880_uniwill_setup(struct hda_codec *codec)
2787 {
2788 	struct alc_spec *spec = codec->spec;
2789 
2790 	spec->autocfg.hp_pins[0] = 0x14;
2791 	spec->autocfg.speaker_pins[0] = 0x15;
2792 	spec->autocfg.speaker_pins[0] = 0x16;
2793 }
2794 
2795 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2796 {
2797 	alc_automute_amp(codec);
2798 	alc880_uniwill_mic_automute(codec);
2799 }
2800 
2801 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2802 				       unsigned int res)
2803 {
2804 	/* Looks like the unsol event is incompatible with the standard
2805 	 * definition.  4bit tag is placed at 28 bit!
2806 	 */
2807 	switch (res >> 28) {
2808 	case ALC880_MIC_EVENT:
2809 		alc880_uniwill_mic_automute(codec);
2810 		break;
2811 	default:
2812 		alc_automute_amp_unsol_event(codec, res);
2813 		break;
2814 	}
2815 }
2816 
2817 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2818 {
2819 	struct alc_spec *spec = codec->spec;
2820 
2821 	spec->autocfg.hp_pins[0] = 0x14;
2822 	spec->autocfg.speaker_pins[0] = 0x15;
2823 }
2824 
2825 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2826 {
2827 	unsigned int present;
2828 
2829 	present = snd_hda_codec_read(codec, 0x21, 0,
2830 				     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2831 	present &= HDA_AMP_VOLMASK;
2832 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2833 				 HDA_AMP_VOLMASK, present);
2834 	snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2835 				 HDA_AMP_VOLMASK, present);
2836 }
2837 
2838 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2839 					   unsigned int res)
2840 {
2841 	/* Looks like the unsol event is incompatible with the standard
2842 	 * definition.  4bit tag is placed at 28 bit!
2843 	 */
2844 	if ((res >> 28) == ALC880_DCVOL_EVENT)
2845 		alc880_uniwill_p53_dcvol_automute(codec);
2846 	else
2847 		alc_automute_amp_unsol_event(codec, res);
2848 }
2849 
2850 /*
2851  * F1734 pin configuration:
2852  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2853  */
2854 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2855 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2856 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2857 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2858 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2859 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2860 
2861 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2862 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2863 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2864 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2865 
2866 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2867 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2868 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2869 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2870 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2871 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2872 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2873 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2874 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2875 
2876 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2877 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2878 
2879 	{ }
2880 };
2881 
2882 /*
2883  * ASUS pin configuration:
2884  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2885  */
2886 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2887 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2888 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2889 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2890 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2891 
2892 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2893 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2894 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2895 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2896 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2897 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2898 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2899 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2900 
2901 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2902 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2903 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2904 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2905 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2906 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2907 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2908 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2909 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2910 
2911 	{ }
2912 };
2913 
2914 /* Enable GPIO mask and set output */
2915 #define alc880_gpio1_init_verbs	alc_gpio1_init_verbs
2916 #define alc880_gpio2_init_verbs	alc_gpio2_init_verbs
2917 #define alc880_gpio3_init_verbs	alc_gpio3_init_verbs
2918 
2919 /* Clevo m520g init */
2920 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2921 	/* headphone output */
2922 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2923 	/* line-out */
2924 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2925 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2926 	/* Line-in */
2927 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2928 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2929 	/* CD */
2930 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2931 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2932 	/* Mic1 (rear panel) */
2933 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2934 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2935 	/* Mic2 (front panel) */
2936 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2937 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2938 	/* headphone */
2939 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2940 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2941         /* change to EAPD mode */
2942 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2943 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2944 
2945 	{ }
2946 };
2947 
2948 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2949 	/* change to EAPD mode */
2950 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2951 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2952 
2953 	/* Headphone output */
2954 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2955 	/* Front output*/
2956 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2957 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2958 
2959 	/* Line In pin widget for input */
2960 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2961 	/* CD pin widget for input */
2962 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2963 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2964 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2965 
2966 	/* change to EAPD mode */
2967 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2968 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2969 
2970 	{ }
2971 };
2972 
2973 /*
2974  * LG m1 express dual
2975  *
2976  * Pin assignment:
2977  *   Rear Line-In/Out (blue): 0x14
2978  *   Build-in Mic-In: 0x15
2979  *   Speaker-out: 0x17
2980  *   HP-Out (green): 0x1b
2981  *   Mic-In/Out (red): 0x19
2982  *   SPDIF-Out: 0x1e
2983  */
2984 
2985 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2986 static hda_nid_t alc880_lg_dac_nids[3] = {
2987 	0x05, 0x02, 0x03
2988 };
2989 
2990 /* seems analog CD is not working */
2991 static struct hda_input_mux alc880_lg_capture_source = {
2992 	.num_items = 3,
2993 	.items = {
2994 		{ "Mic", 0x1 },
2995 		{ "Line", 0x5 },
2996 		{ "Internal Mic", 0x6 },
2997 	},
2998 };
2999 
3000 /* 2,4,6 channel modes */
3001 static struct hda_verb alc880_lg_ch2_init[] = {
3002 	/* set line-in and mic-in to input */
3003 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3004 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3005 	{ }
3006 };
3007 
3008 static struct hda_verb alc880_lg_ch4_init[] = {
3009 	/* set line-in to out and mic-in to input */
3010 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3011 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3012 	{ }
3013 };
3014 
3015 static struct hda_verb alc880_lg_ch6_init[] = {
3016 	/* set line-in and mic-in to output */
3017 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3018 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3019 	{ }
3020 };
3021 
3022 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3023 	{ 2, alc880_lg_ch2_init },
3024 	{ 4, alc880_lg_ch4_init },
3025 	{ 6, alc880_lg_ch6_init },
3026 };
3027 
3028 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3029 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3030 	HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3031 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3032 	HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3033 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3034 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3035 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3036 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3037 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3038 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3039 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3040 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3041 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3042 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3043 	{
3044 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3045 		.name = "Channel Mode",
3046 		.info = alc_ch_mode_info,
3047 		.get = alc_ch_mode_get,
3048 		.put = alc_ch_mode_put,
3049 	},
3050 	{ } /* end */
3051 };
3052 
3053 static struct hda_verb alc880_lg_init_verbs[] = {
3054 	/* set capture source to mic-in */
3055 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3056 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3057 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3058 	/* mute all amp mixer inputs */
3059 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3060 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3061 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3062 	/* line-in to input */
3063 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3064 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3065 	/* built-in mic */
3066 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3067 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3068 	/* speaker-out */
3069 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3070 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3071 	/* mic-in to input */
3072 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3073 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3074 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3075 	/* HP-out */
3076 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3077 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3078 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3079 	/* jack sense */
3080 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3081 	{ }
3082 };
3083 
3084 /* toggle speaker-output according to the hp-jack state */
3085 static void alc880_lg_setup(struct hda_codec *codec)
3086 {
3087 	struct alc_spec *spec = codec->spec;
3088 
3089 	spec->autocfg.hp_pins[0] = 0x1b;
3090 	spec->autocfg.speaker_pins[0] = 0x17;
3091 }
3092 
3093 /*
3094  * LG LW20
3095  *
3096  * Pin assignment:
3097  *   Speaker-out: 0x14
3098  *   Mic-In: 0x18
3099  *   Built-in Mic-In: 0x19
3100  *   Line-In: 0x1b
3101  *   HP-Out: 0x1a
3102  *   SPDIF-Out: 0x1e
3103  */
3104 
3105 static struct hda_input_mux alc880_lg_lw_capture_source = {
3106 	.num_items = 3,
3107 	.items = {
3108 		{ "Mic", 0x0 },
3109 		{ "Internal Mic", 0x1 },
3110 		{ "Line In", 0x2 },
3111 	},
3112 };
3113 
3114 #define alc880_lg_lw_modes alc880_threestack_modes
3115 
3116 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3117 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3118 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3119 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3120 	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3121 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3122 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3123 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3124 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3125 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3126 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3127 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3128 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3129 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3130 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3131 	{
3132 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3133 		.name = "Channel Mode",
3134 		.info = alc_ch_mode_info,
3135 		.get = alc_ch_mode_get,
3136 		.put = alc_ch_mode_put,
3137 	},
3138 	{ } /* end */
3139 };
3140 
3141 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3142 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3143 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3144 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3145 
3146 	/* set capture source to mic-in */
3147 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3148 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3149 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3150 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3151 	/* speaker-out */
3152 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3153 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3154 	/* HP-out */
3155 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3156 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3157 	/* mic-in to input */
3158 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3159 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3160 	/* built-in mic */
3161 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3162 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3163 	/* jack sense */
3164 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3165 	{ }
3166 };
3167 
3168 /* toggle speaker-output according to the hp-jack state */
3169 static void alc880_lg_lw_setup(struct hda_codec *codec)
3170 {
3171 	struct alc_spec *spec = codec->spec;
3172 
3173 	spec->autocfg.hp_pins[0] = 0x1b;
3174 	spec->autocfg.speaker_pins[0] = 0x14;
3175 }
3176 
3177 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3178 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3179 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3180 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3181 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3182 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3183 	HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3184 	{ } /* end */
3185 };
3186 
3187 static struct hda_input_mux alc880_medion_rim_capture_source = {
3188 	.num_items = 2,
3189 	.items = {
3190 		{ "Mic", 0x0 },
3191 		{ "Internal Mic", 0x1 },
3192 	},
3193 };
3194 
3195 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3196 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3197 
3198 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3199 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3200 
3201 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3202 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3203 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3204 	/* Mic2 (as headphone out) for HP output */
3205 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3206 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3207 	/* Internal Speaker */
3208 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3209 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3210 
3211 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3212 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3213 
3214 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3215 	{ }
3216 };
3217 
3218 /* toggle speaker-output according to the hp-jack state */
3219 static void alc880_medion_rim_automute(struct hda_codec *codec)
3220 {
3221 	struct alc_spec *spec = codec->spec;
3222 	alc_automute_amp(codec);
3223 	/* toggle EAPD */
3224 	if (spec->jack_present)
3225 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3226 	else
3227 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3228 }
3229 
3230 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3231 					  unsigned int res)
3232 {
3233 	/* Looks like the unsol event is incompatible with the standard
3234 	 * definition.  4bit tag is placed at 28 bit!
3235 	 */
3236 	if ((res >> 28) == ALC880_HP_EVENT)
3237 		alc880_medion_rim_automute(codec);
3238 }
3239 
3240 static void alc880_medion_rim_setup(struct hda_codec *codec)
3241 {
3242 	struct alc_spec *spec = codec->spec;
3243 
3244 	spec->autocfg.hp_pins[0] = 0x14;
3245 	spec->autocfg.speaker_pins[0] = 0x1b;
3246 }
3247 
3248 #ifdef CONFIG_SND_HDA_POWER_SAVE
3249 static struct hda_amp_list alc880_loopbacks[] = {
3250 	{ 0x0b, HDA_INPUT, 0 },
3251 	{ 0x0b, HDA_INPUT, 1 },
3252 	{ 0x0b, HDA_INPUT, 2 },
3253 	{ 0x0b, HDA_INPUT, 3 },
3254 	{ 0x0b, HDA_INPUT, 4 },
3255 	{ } /* end */
3256 };
3257 
3258 static struct hda_amp_list alc880_lg_loopbacks[] = {
3259 	{ 0x0b, HDA_INPUT, 1 },
3260 	{ 0x0b, HDA_INPUT, 6 },
3261 	{ 0x0b, HDA_INPUT, 7 },
3262 	{ } /* end */
3263 };
3264 #endif
3265 
3266 /*
3267  * Common callbacks
3268  */
3269 
3270 static int alc_init(struct hda_codec *codec)
3271 {
3272 	struct alc_spec *spec = codec->spec;
3273 	unsigned int i;
3274 
3275 	alc_fix_pll(codec);
3276 	alc_auto_init_amp(codec, spec->init_amp);
3277 
3278 	for (i = 0; i < spec->num_init_verbs; i++)
3279 		snd_hda_sequence_write(codec, spec->init_verbs[i]);
3280 
3281 	if (spec->init_hook)
3282 		spec->init_hook(codec);
3283 
3284 	return 0;
3285 }
3286 
3287 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3288 {
3289 	struct alc_spec *spec = codec->spec;
3290 
3291 	if (spec->unsol_event)
3292 		spec->unsol_event(codec, res);
3293 }
3294 
3295 #ifdef CONFIG_SND_HDA_POWER_SAVE
3296 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3297 {
3298 	struct alc_spec *spec = codec->spec;
3299 	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3300 }
3301 #endif
3302 
3303 /*
3304  * Analog playback callbacks
3305  */
3306 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3307 				    struct hda_codec *codec,
3308 				    struct snd_pcm_substream *substream)
3309 {
3310 	struct alc_spec *spec = codec->spec;
3311 	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3312 					     hinfo);
3313 }
3314 
3315 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3316 				       struct hda_codec *codec,
3317 				       unsigned int stream_tag,
3318 				       unsigned int format,
3319 				       struct snd_pcm_substream *substream)
3320 {
3321 	struct alc_spec *spec = codec->spec;
3322 	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3323 						stream_tag, format, substream);
3324 }
3325 
3326 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3327 				       struct hda_codec *codec,
3328 				       struct snd_pcm_substream *substream)
3329 {
3330 	struct alc_spec *spec = codec->spec;
3331 	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3332 }
3333 
3334 /*
3335  * Digital out
3336  */
3337 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3338 					struct hda_codec *codec,
3339 					struct snd_pcm_substream *substream)
3340 {
3341 	struct alc_spec *spec = codec->spec;
3342 	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3343 }
3344 
3345 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3346 					   struct hda_codec *codec,
3347 					   unsigned int stream_tag,
3348 					   unsigned int format,
3349 					   struct snd_pcm_substream *substream)
3350 {
3351 	struct alc_spec *spec = codec->spec;
3352 	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3353 					     stream_tag, format, substream);
3354 }
3355 
3356 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3357 					   struct hda_codec *codec,
3358 					   struct snd_pcm_substream *substream)
3359 {
3360 	struct alc_spec *spec = codec->spec;
3361 	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3362 }
3363 
3364 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3365 					 struct hda_codec *codec,
3366 					 struct snd_pcm_substream *substream)
3367 {
3368 	struct alc_spec *spec = codec->spec;
3369 	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3370 }
3371 
3372 /*
3373  * Analog capture
3374  */
3375 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3376 				      struct hda_codec *codec,
3377 				      unsigned int stream_tag,
3378 				      unsigned int format,
3379 				      struct snd_pcm_substream *substream)
3380 {
3381 	struct alc_spec *spec = codec->spec;
3382 
3383 	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3384 				   stream_tag, 0, format);
3385 	return 0;
3386 }
3387 
3388 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3389 				      struct hda_codec *codec,
3390 				      struct snd_pcm_substream *substream)
3391 {
3392 	struct alc_spec *spec = codec->spec;
3393 
3394 	snd_hda_codec_cleanup_stream(codec,
3395 				     spec->adc_nids[substream->number + 1]);
3396 	return 0;
3397 }
3398 
3399 
3400 /*
3401  */
3402 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3403 	.substreams = 1,
3404 	.channels_min = 2,
3405 	.channels_max = 8,
3406 	/* NID is set in alc_build_pcms */
3407 	.ops = {
3408 		.open = alc880_playback_pcm_open,
3409 		.prepare = alc880_playback_pcm_prepare,
3410 		.cleanup = alc880_playback_pcm_cleanup
3411 	},
3412 };
3413 
3414 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3415 	.substreams = 1,
3416 	.channels_min = 2,
3417 	.channels_max = 2,
3418 	/* NID is set in alc_build_pcms */
3419 };
3420 
3421 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3422 	.substreams = 1,
3423 	.channels_min = 2,
3424 	.channels_max = 2,
3425 	/* NID is set in alc_build_pcms */
3426 };
3427 
3428 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3429 	.substreams = 2, /* can be overridden */
3430 	.channels_min = 2,
3431 	.channels_max = 2,
3432 	/* NID is set in alc_build_pcms */
3433 	.ops = {
3434 		.prepare = alc880_alt_capture_pcm_prepare,
3435 		.cleanup = alc880_alt_capture_pcm_cleanup
3436 	},
3437 };
3438 
3439 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3440 	.substreams = 1,
3441 	.channels_min = 2,
3442 	.channels_max = 2,
3443 	/* NID is set in alc_build_pcms */
3444 	.ops = {
3445 		.open = alc880_dig_playback_pcm_open,
3446 		.close = alc880_dig_playback_pcm_close,
3447 		.prepare = alc880_dig_playback_pcm_prepare,
3448 		.cleanup = alc880_dig_playback_pcm_cleanup
3449 	},
3450 };
3451 
3452 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3453 	.substreams = 1,
3454 	.channels_min = 2,
3455 	.channels_max = 2,
3456 	/* NID is set in alc_build_pcms */
3457 };
3458 
3459 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3460 static struct hda_pcm_stream alc_pcm_null_stream = {
3461 	.substreams = 0,
3462 	.channels_min = 0,
3463 	.channels_max = 0,
3464 };
3465 
3466 static int alc_build_pcms(struct hda_codec *codec)
3467 {
3468 	struct alc_spec *spec = codec->spec;
3469 	struct hda_pcm *info = spec->pcm_rec;
3470 	int i;
3471 
3472 	codec->num_pcms = 1;
3473 	codec->pcm_info = info;
3474 
3475 	if (spec->no_analog)
3476 		goto skip_analog;
3477 
3478 	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3479 		 "%s Analog", codec->chip_name);
3480 	info->name = spec->stream_name_analog;
3481 
3482 	if (spec->stream_analog_playback) {
3483 		if (snd_BUG_ON(!spec->multiout.dac_nids))
3484 			return -EINVAL;
3485 		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3486 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3487 	}
3488 	if (spec->stream_analog_capture) {
3489 		if (snd_BUG_ON(!spec->adc_nids))
3490 			return -EINVAL;
3491 		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3492 		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3493 	}
3494 
3495 	if (spec->channel_mode) {
3496 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3497 		for (i = 0; i < spec->num_channel_mode; i++) {
3498 			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3499 				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3500 			}
3501 		}
3502 	}
3503 
3504  skip_analog:
3505 	/* SPDIF for stream index #1 */
3506 	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3507 		snprintf(spec->stream_name_digital,
3508 			 sizeof(spec->stream_name_digital),
3509 			 "%s Digital", codec->chip_name);
3510 		codec->num_pcms = 2;
3511 	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3512 		info = spec->pcm_rec + 1;
3513 		info->name = spec->stream_name_digital;
3514 		if (spec->dig_out_type)
3515 			info->pcm_type = spec->dig_out_type;
3516 		else
3517 			info->pcm_type = HDA_PCM_TYPE_SPDIF;
3518 		if (spec->multiout.dig_out_nid &&
3519 		    spec->stream_digital_playback) {
3520 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3521 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3522 		}
3523 		if (spec->dig_in_nid &&
3524 		    spec->stream_digital_capture) {
3525 			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3526 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3527 		}
3528 		/* FIXME: do we need this for all Realtek codec models? */
3529 		codec->spdif_status_reset = 1;
3530 	}
3531 
3532 	if (spec->no_analog)
3533 		return 0;
3534 
3535 	/* If the use of more than one ADC is requested for the current
3536 	 * model, configure a second analog capture-only PCM.
3537 	 */
3538 	/* Additional Analaog capture for index #2 */
3539 	if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3540 	    (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3541 		codec->num_pcms = 3;
3542 		info = spec->pcm_rec + 2;
3543 		info->name = spec->stream_name_analog;
3544 		if (spec->alt_dac_nid) {
3545 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3546 				*spec->stream_analog_alt_playback;
3547 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3548 				spec->alt_dac_nid;
3549 		} else {
3550 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3551 				alc_pcm_null_stream;
3552 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3553 		}
3554 		if (spec->num_adc_nids > 1) {
3555 			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3556 				*spec->stream_analog_alt_capture;
3557 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3558 				spec->adc_nids[1];
3559 			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3560 				spec->num_adc_nids - 1;
3561 		} else {
3562 			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3563 				alc_pcm_null_stream;
3564 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3565 		}
3566 	}
3567 
3568 	return 0;
3569 }
3570 
3571 static void alc_free_kctls(struct hda_codec *codec)
3572 {
3573 	struct alc_spec *spec = codec->spec;
3574 
3575 	if (spec->kctls.list) {
3576 		struct snd_kcontrol_new *kctl = spec->kctls.list;
3577 		int i;
3578 		for (i = 0; i < spec->kctls.used; i++)
3579 			kfree(kctl[i].name);
3580 	}
3581 	snd_array_free(&spec->kctls);
3582 }
3583 
3584 static void alc_free(struct hda_codec *codec)
3585 {
3586 	struct alc_spec *spec = codec->spec;
3587 
3588 	if (!spec)
3589 		return;
3590 
3591 	alc_free_kctls(codec);
3592 	kfree(spec);
3593 	snd_hda_detach_beep_device(codec);
3594 }
3595 
3596 #ifdef SND_HDA_NEEDS_RESUME
3597 static int alc_resume(struct hda_codec *codec)
3598 {
3599 	codec->patch_ops.init(codec);
3600 	snd_hda_codec_resume_amp(codec);
3601 	snd_hda_codec_resume_cache(codec);
3602 	return 0;
3603 }
3604 #endif
3605 
3606 /*
3607  */
3608 static struct hda_codec_ops alc_patch_ops = {
3609 	.build_controls = alc_build_controls,
3610 	.build_pcms = alc_build_pcms,
3611 	.init = alc_init,
3612 	.free = alc_free,
3613 	.unsol_event = alc_unsol_event,
3614 #ifdef SND_HDA_NEEDS_RESUME
3615 	.resume = alc_resume,
3616 #endif
3617 #ifdef CONFIG_SND_HDA_POWER_SAVE
3618 	.check_power_status = alc_check_power_status,
3619 #endif
3620 };
3621 
3622 
3623 /*
3624  * Test configuration for debugging
3625  *
3626  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3627  * enum controls.
3628  */
3629 #ifdef CONFIG_SND_DEBUG
3630 static hda_nid_t alc880_test_dac_nids[4] = {
3631 	0x02, 0x03, 0x04, 0x05
3632 };
3633 
3634 static struct hda_input_mux alc880_test_capture_source = {
3635 	.num_items = 7,
3636 	.items = {
3637 		{ "In-1", 0x0 },
3638 		{ "In-2", 0x1 },
3639 		{ "In-3", 0x2 },
3640 		{ "In-4", 0x3 },
3641 		{ "CD", 0x4 },
3642 		{ "Front", 0x5 },
3643 		{ "Surround", 0x6 },
3644 	},
3645 };
3646 
3647 static struct hda_channel_mode alc880_test_modes[4] = {
3648 	{ 2, NULL },
3649 	{ 4, NULL },
3650 	{ 6, NULL },
3651 	{ 8, NULL },
3652 };
3653 
3654 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3655 				 struct snd_ctl_elem_info *uinfo)
3656 {
3657 	static char *texts[] = {
3658 		"N/A", "Line Out", "HP Out",
3659 		"In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3660 	};
3661 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3662 	uinfo->count = 1;
3663 	uinfo->value.enumerated.items = 8;
3664 	if (uinfo->value.enumerated.item >= 8)
3665 		uinfo->value.enumerated.item = 7;
3666 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3667 	return 0;
3668 }
3669 
3670 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3671 				struct snd_ctl_elem_value *ucontrol)
3672 {
3673 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3674 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3675 	unsigned int pin_ctl, item = 0;
3676 
3677 	pin_ctl = snd_hda_codec_read(codec, nid, 0,
3678 				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3679 	if (pin_ctl & AC_PINCTL_OUT_EN) {
3680 		if (pin_ctl & AC_PINCTL_HP_EN)
3681 			item = 2;
3682 		else
3683 			item = 1;
3684 	} else if (pin_ctl & AC_PINCTL_IN_EN) {
3685 		switch (pin_ctl & AC_PINCTL_VREFEN) {
3686 		case AC_PINCTL_VREF_HIZ: item = 3; break;
3687 		case AC_PINCTL_VREF_50:  item = 4; break;
3688 		case AC_PINCTL_VREF_GRD: item = 5; break;
3689 		case AC_PINCTL_VREF_80:  item = 6; break;
3690 		case AC_PINCTL_VREF_100: item = 7; break;
3691 		}
3692 	}
3693 	ucontrol->value.enumerated.item[0] = item;
3694 	return 0;
3695 }
3696 
3697 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3698 				struct snd_ctl_elem_value *ucontrol)
3699 {
3700 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3701 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3702 	static unsigned int ctls[] = {
3703 		0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3704 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3705 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3706 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3707 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3708 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3709 	};
3710 	unsigned int old_ctl, new_ctl;
3711 
3712 	old_ctl = snd_hda_codec_read(codec, nid, 0,
3713 				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3714 	new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3715 	if (old_ctl != new_ctl) {
3716 		int val;
3717 		snd_hda_codec_write_cache(codec, nid, 0,
3718 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
3719 					  new_ctl);
3720 		val = ucontrol->value.enumerated.item[0] >= 3 ?
3721 			HDA_AMP_MUTE : 0;
3722 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3723 					 HDA_AMP_MUTE, val);
3724 		return 1;
3725 	}
3726 	return 0;
3727 }
3728 
3729 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3730 				 struct snd_ctl_elem_info *uinfo)
3731 {
3732 	static char *texts[] = {
3733 		"Front", "Surround", "CLFE", "Side"
3734 	};
3735 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3736 	uinfo->count = 1;
3737 	uinfo->value.enumerated.items = 4;
3738 	if (uinfo->value.enumerated.item >= 4)
3739 		uinfo->value.enumerated.item = 3;
3740 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3741 	return 0;
3742 }
3743 
3744 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3745 				struct snd_ctl_elem_value *ucontrol)
3746 {
3747 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3748 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3749 	unsigned int sel;
3750 
3751 	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3752 	ucontrol->value.enumerated.item[0] = sel & 3;
3753 	return 0;
3754 }
3755 
3756 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3757 				struct snd_ctl_elem_value *ucontrol)
3758 {
3759 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3760 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3761 	unsigned int sel;
3762 
3763 	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3764 	if (ucontrol->value.enumerated.item[0] != sel) {
3765 		sel = ucontrol->value.enumerated.item[0] & 3;
3766 		snd_hda_codec_write_cache(codec, nid, 0,
3767 					  AC_VERB_SET_CONNECT_SEL, sel);
3768 		return 1;
3769 	}
3770 	return 0;
3771 }
3772 
3773 #define PIN_CTL_TEST(xname,nid) {			\
3774 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
3775 			.name = xname,		       \
3776 			.info = alc_test_pin_ctl_info, \
3777 			.get = alc_test_pin_ctl_get,   \
3778 			.put = alc_test_pin_ctl_put,   \
3779 			.private_value = nid	       \
3780 			}
3781 
3782 #define PIN_SRC_TEST(xname,nid) {			\
3783 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
3784 			.name = xname,		       \
3785 			.info = alc_test_pin_src_info, \
3786 			.get = alc_test_pin_src_get,   \
3787 			.put = alc_test_pin_src_put,   \
3788 			.private_value = nid	       \
3789 			}
3790 
3791 static struct snd_kcontrol_new alc880_test_mixer[] = {
3792 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3793 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3794 	HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3795 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3796 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3797 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3798 	HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3799 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3800 	PIN_CTL_TEST("Front Pin Mode", 0x14),
3801 	PIN_CTL_TEST("Surround Pin Mode", 0x15),
3802 	PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3803 	PIN_CTL_TEST("Side Pin Mode", 0x17),
3804 	PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3805 	PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3806 	PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3807 	PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3808 	PIN_SRC_TEST("In-1 Pin Source", 0x18),
3809 	PIN_SRC_TEST("In-2 Pin Source", 0x19),
3810 	PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3811 	PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3812 	HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3813 	HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3814 	HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3815 	HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3816 	HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3817 	HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3818 	HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3819 	HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3820 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3821 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3822 	{
3823 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3824 		.name = "Channel Mode",
3825 		.info = alc_ch_mode_info,
3826 		.get = alc_ch_mode_get,
3827 		.put = alc_ch_mode_put,
3828 	},
3829 	{ } /* end */
3830 };
3831 
3832 static struct hda_verb alc880_test_init_verbs[] = {
3833 	/* Unmute inputs of 0x0c - 0x0f */
3834 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3835 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3836 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3837 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3838 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3839 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3840 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3841 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3842 	/* Vol output for 0x0c-0x0f */
3843 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3844 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3845 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3846 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3847 	/* Set output pins 0x14-0x17 */
3848 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3849 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3850 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3851 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3852 	/* Unmute output pins 0x14-0x17 */
3853 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3854 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3855 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3856 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3857 	/* Set input pins 0x18-0x1c */
3858 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3859 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3860 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3861 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3862 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3863 	/* Mute input pins 0x18-0x1b */
3864 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3865 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3866 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3867 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3868 	/* ADC set up */
3869 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3870 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3871 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3872 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3873 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3874 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3875 	/* Analog input/passthru */
3876 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3877 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3878 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3879 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3880 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3881 	{ }
3882 };
3883 #endif
3884 
3885 /*
3886  */
3887 
3888 static const char *alc880_models[ALC880_MODEL_LAST] = {
3889 	[ALC880_3ST]		= "3stack",
3890 	[ALC880_TCL_S700]	= "tcl",
3891 	[ALC880_3ST_DIG]	= "3stack-digout",
3892 	[ALC880_CLEVO]		= "clevo",
3893 	[ALC880_5ST]		= "5stack",
3894 	[ALC880_5ST_DIG]	= "5stack-digout",
3895 	[ALC880_W810]		= "w810",
3896 	[ALC880_Z71V]		= "z71v",
3897 	[ALC880_6ST]		= "6stack",
3898 	[ALC880_6ST_DIG]	= "6stack-digout",
3899 	[ALC880_ASUS]		= "asus",
3900 	[ALC880_ASUS_W1V]	= "asus-w1v",
3901 	[ALC880_ASUS_DIG]	= "asus-dig",
3902 	[ALC880_ASUS_DIG2]	= "asus-dig2",
3903 	[ALC880_UNIWILL_DIG]	= "uniwill",
3904 	[ALC880_UNIWILL_P53]	= "uniwill-p53",
3905 	[ALC880_FUJITSU]	= "fujitsu",
3906 	[ALC880_F1734]		= "F1734",
3907 	[ALC880_LG]		= "lg",
3908 	[ALC880_LG_LW]		= "lg-lw",
3909 	[ALC880_MEDION_RIM]	= "medion",
3910 #ifdef CONFIG_SND_DEBUG
3911 	[ALC880_TEST]		= "test",
3912 #endif
3913 	[ALC880_AUTO]		= "auto",
3914 };
3915 
3916 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3917 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3918 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3919 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3920 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3921 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3922 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3923 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3924 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3925 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3926 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3927 	SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3928 	SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3929 	SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3930 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3931 	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3932 	SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3933 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3934 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3935 	/* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3936 	SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3937 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3938 	SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3939 	SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3940 	SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3941 	SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3942 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3943 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3944 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3945 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3946 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3947 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3948 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3949 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3950 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3951 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3952 	SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3953 	SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3954 	SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3955 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3956 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3957 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3958 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3959 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3960 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3961 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3962 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3963 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3964 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3965 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3966 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3967 	SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3968 	SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3969 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3970 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3971 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3972 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3973 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3974 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3975 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3976 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3977 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3978 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3979 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3980 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3981 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3982 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3983 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3984 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3985 	/* default Intel */
3986 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3987 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3988 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3989 	{}
3990 };
3991 
3992 /*
3993  * ALC880 codec presets
3994  */
3995 static struct alc_config_preset alc880_presets[] = {
3996 	[ALC880_3ST] = {
3997 		.mixers = { alc880_three_stack_mixer },
3998 		.init_verbs = { alc880_volume_init_verbs,
3999 				alc880_pin_3stack_init_verbs },
4000 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4001 		.dac_nids = alc880_dac_nids,
4002 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4003 		.channel_mode = alc880_threestack_modes,
4004 		.need_dac_fix = 1,
4005 		.input_mux = &alc880_capture_source,
4006 	},
4007 	[ALC880_3ST_DIG] = {
4008 		.mixers = { alc880_three_stack_mixer },
4009 		.init_verbs = { alc880_volume_init_verbs,
4010 				alc880_pin_3stack_init_verbs },
4011 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4012 		.dac_nids = alc880_dac_nids,
4013 		.dig_out_nid = ALC880_DIGOUT_NID,
4014 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4015 		.channel_mode = alc880_threestack_modes,
4016 		.need_dac_fix = 1,
4017 		.input_mux = &alc880_capture_source,
4018 	},
4019 	[ALC880_TCL_S700] = {
4020 		.mixers = { alc880_tcl_s700_mixer },
4021 		.init_verbs = { alc880_volume_init_verbs,
4022 				alc880_pin_tcl_S700_init_verbs,
4023 				alc880_gpio2_init_verbs },
4024 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4025 		.dac_nids = alc880_dac_nids,
4026 		.adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4027 		.num_adc_nids = 1, /* single ADC */
4028 		.hp_nid = 0x03,
4029 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4030 		.channel_mode = alc880_2_jack_modes,
4031 		.input_mux = &alc880_capture_source,
4032 	},
4033 	[ALC880_5ST] = {
4034 		.mixers = { alc880_three_stack_mixer,
4035 			    alc880_five_stack_mixer},
4036 		.init_verbs = { alc880_volume_init_verbs,
4037 				alc880_pin_5stack_init_verbs },
4038 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4039 		.dac_nids = alc880_dac_nids,
4040 		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4041 		.channel_mode = alc880_fivestack_modes,
4042 		.input_mux = &alc880_capture_source,
4043 	},
4044 	[ALC880_5ST_DIG] = {
4045 		.mixers = { alc880_three_stack_mixer,
4046 			    alc880_five_stack_mixer },
4047 		.init_verbs = { alc880_volume_init_verbs,
4048 				alc880_pin_5stack_init_verbs },
4049 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4050 		.dac_nids = alc880_dac_nids,
4051 		.dig_out_nid = ALC880_DIGOUT_NID,
4052 		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4053 		.channel_mode = alc880_fivestack_modes,
4054 		.input_mux = &alc880_capture_source,
4055 	},
4056 	[ALC880_6ST] = {
4057 		.mixers = { alc880_six_stack_mixer },
4058 		.init_verbs = { alc880_volume_init_verbs,
4059 				alc880_pin_6stack_init_verbs },
4060 		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4061 		.dac_nids = alc880_6st_dac_nids,
4062 		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4063 		.channel_mode = alc880_sixstack_modes,
4064 		.input_mux = &alc880_6stack_capture_source,
4065 	},
4066 	[ALC880_6ST_DIG] = {
4067 		.mixers = { alc880_six_stack_mixer },
4068 		.init_verbs = { alc880_volume_init_verbs,
4069 				alc880_pin_6stack_init_verbs },
4070 		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4071 		.dac_nids = alc880_6st_dac_nids,
4072 		.dig_out_nid = ALC880_DIGOUT_NID,
4073 		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4074 		.channel_mode = alc880_sixstack_modes,
4075 		.input_mux = &alc880_6stack_capture_source,
4076 	},
4077 	[ALC880_W810] = {
4078 		.mixers = { alc880_w810_base_mixer },
4079 		.init_verbs = { alc880_volume_init_verbs,
4080 				alc880_pin_w810_init_verbs,
4081 				alc880_gpio2_init_verbs },
4082 		.num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4083 		.dac_nids = alc880_w810_dac_nids,
4084 		.dig_out_nid = ALC880_DIGOUT_NID,
4085 		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4086 		.channel_mode = alc880_w810_modes,
4087 		.input_mux = &alc880_capture_source,
4088 	},
4089 	[ALC880_Z71V] = {
4090 		.mixers = { alc880_z71v_mixer },
4091 		.init_verbs = { alc880_volume_init_verbs,
4092 				alc880_pin_z71v_init_verbs },
4093 		.num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4094 		.dac_nids = alc880_z71v_dac_nids,
4095 		.dig_out_nid = ALC880_DIGOUT_NID,
4096 		.hp_nid = 0x03,
4097 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4098 		.channel_mode = alc880_2_jack_modes,
4099 		.input_mux = &alc880_capture_source,
4100 	},
4101 	[ALC880_F1734] = {
4102 		.mixers = { alc880_f1734_mixer },
4103 		.init_verbs = { alc880_volume_init_verbs,
4104 				alc880_pin_f1734_init_verbs },
4105 		.num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4106 		.dac_nids = alc880_f1734_dac_nids,
4107 		.hp_nid = 0x02,
4108 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4109 		.channel_mode = alc880_2_jack_modes,
4110 		.input_mux = &alc880_f1734_capture_source,
4111 		.unsol_event = alc880_uniwill_p53_unsol_event,
4112 		.setup = alc880_uniwill_p53_setup,
4113 		.init_hook = alc_automute_amp,
4114 	},
4115 	[ALC880_ASUS] = {
4116 		.mixers = { alc880_asus_mixer },
4117 		.init_verbs = { alc880_volume_init_verbs,
4118 				alc880_pin_asus_init_verbs,
4119 				alc880_gpio1_init_verbs },
4120 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4121 		.dac_nids = alc880_asus_dac_nids,
4122 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4123 		.channel_mode = alc880_asus_modes,
4124 		.need_dac_fix = 1,
4125 		.input_mux = &alc880_capture_source,
4126 	},
4127 	[ALC880_ASUS_DIG] = {
4128 		.mixers = { alc880_asus_mixer },
4129 		.init_verbs = { alc880_volume_init_verbs,
4130 				alc880_pin_asus_init_verbs,
4131 				alc880_gpio1_init_verbs },
4132 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4133 		.dac_nids = alc880_asus_dac_nids,
4134 		.dig_out_nid = ALC880_DIGOUT_NID,
4135 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4136 		.channel_mode = alc880_asus_modes,
4137 		.need_dac_fix = 1,
4138 		.input_mux = &alc880_capture_source,
4139 	},
4140 	[ALC880_ASUS_DIG2] = {
4141 		.mixers = { alc880_asus_mixer },
4142 		.init_verbs = { alc880_volume_init_verbs,
4143 				alc880_pin_asus_init_verbs,
4144 				alc880_gpio2_init_verbs }, /* use GPIO2 */
4145 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4146 		.dac_nids = alc880_asus_dac_nids,
4147 		.dig_out_nid = ALC880_DIGOUT_NID,
4148 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4149 		.channel_mode = alc880_asus_modes,
4150 		.need_dac_fix = 1,
4151 		.input_mux = &alc880_capture_source,
4152 	},
4153 	[ALC880_ASUS_W1V] = {
4154 		.mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4155 		.init_verbs = { alc880_volume_init_verbs,
4156 				alc880_pin_asus_init_verbs,
4157 				alc880_gpio1_init_verbs },
4158 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4159 		.dac_nids = alc880_asus_dac_nids,
4160 		.dig_out_nid = ALC880_DIGOUT_NID,
4161 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4162 		.channel_mode = alc880_asus_modes,
4163 		.need_dac_fix = 1,
4164 		.input_mux = &alc880_capture_source,
4165 	},
4166 	[ALC880_UNIWILL_DIG] = {
4167 		.mixers = { alc880_asus_mixer },
4168 		.init_verbs = { alc880_volume_init_verbs,
4169 				alc880_pin_asus_init_verbs },
4170 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4171 		.dac_nids = alc880_asus_dac_nids,
4172 		.dig_out_nid = ALC880_DIGOUT_NID,
4173 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4174 		.channel_mode = alc880_asus_modes,
4175 		.need_dac_fix = 1,
4176 		.input_mux = &alc880_capture_source,
4177 	},
4178 	[ALC880_UNIWILL] = {
4179 		.mixers = { alc880_uniwill_mixer },
4180 		.init_verbs = { alc880_volume_init_verbs,
4181 				alc880_uniwill_init_verbs },
4182 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4183 		.dac_nids = alc880_asus_dac_nids,
4184 		.dig_out_nid = ALC880_DIGOUT_NID,
4185 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4186 		.channel_mode = alc880_threestack_modes,
4187 		.need_dac_fix = 1,
4188 		.input_mux = &alc880_capture_source,
4189 		.unsol_event = alc880_uniwill_unsol_event,
4190 		.setup = alc880_uniwill_setup,
4191 		.init_hook = alc880_uniwill_init_hook,
4192 	},
4193 	[ALC880_UNIWILL_P53] = {
4194 		.mixers = { alc880_uniwill_p53_mixer },
4195 		.init_verbs = { alc880_volume_init_verbs,
4196 				alc880_uniwill_p53_init_verbs },
4197 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4198 		.dac_nids = alc880_asus_dac_nids,
4199 		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4200 		.channel_mode = alc880_threestack_modes,
4201 		.input_mux = &alc880_capture_source,
4202 		.unsol_event = alc880_uniwill_p53_unsol_event,
4203 		.setup = alc880_uniwill_p53_setup,
4204 		.init_hook = alc_automute_amp,
4205 	},
4206 	[ALC880_FUJITSU] = {
4207 		.mixers = { alc880_fujitsu_mixer },
4208 		.init_verbs = { alc880_volume_init_verbs,
4209 				alc880_uniwill_p53_init_verbs,
4210 	       			alc880_beep_init_verbs },
4211 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4212 		.dac_nids = alc880_dac_nids,
4213 		.dig_out_nid = ALC880_DIGOUT_NID,
4214 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4215 		.channel_mode = alc880_2_jack_modes,
4216 		.input_mux = &alc880_capture_source,
4217 		.unsol_event = alc880_uniwill_p53_unsol_event,
4218 		.setup = alc880_uniwill_p53_setup,
4219 		.init_hook = alc_automute_amp,
4220 	},
4221 	[ALC880_CLEVO] = {
4222 		.mixers = { alc880_three_stack_mixer },
4223 		.init_verbs = { alc880_volume_init_verbs,
4224 				alc880_pin_clevo_init_verbs },
4225 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4226 		.dac_nids = alc880_dac_nids,
4227 		.hp_nid = 0x03,
4228 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4229 		.channel_mode = alc880_threestack_modes,
4230 		.need_dac_fix = 1,
4231 		.input_mux = &alc880_capture_source,
4232 	},
4233 	[ALC880_LG] = {
4234 		.mixers = { alc880_lg_mixer },
4235 		.init_verbs = { alc880_volume_init_verbs,
4236 				alc880_lg_init_verbs },
4237 		.num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4238 		.dac_nids = alc880_lg_dac_nids,
4239 		.dig_out_nid = ALC880_DIGOUT_NID,
4240 		.num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4241 		.channel_mode = alc880_lg_ch_modes,
4242 		.need_dac_fix = 1,
4243 		.input_mux = &alc880_lg_capture_source,
4244 		.unsol_event = alc_automute_amp_unsol_event,
4245 		.setup = alc880_lg_setup,
4246 		.init_hook = alc_automute_amp,
4247 #ifdef CONFIG_SND_HDA_POWER_SAVE
4248 		.loopbacks = alc880_lg_loopbacks,
4249 #endif
4250 	},
4251 	[ALC880_LG_LW] = {
4252 		.mixers = { alc880_lg_lw_mixer },
4253 		.init_verbs = { alc880_volume_init_verbs,
4254 				alc880_lg_lw_init_verbs },
4255 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4256 		.dac_nids = alc880_dac_nids,
4257 		.dig_out_nid = ALC880_DIGOUT_NID,
4258 		.num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4259 		.channel_mode = alc880_lg_lw_modes,
4260 		.input_mux = &alc880_lg_lw_capture_source,
4261 		.unsol_event = alc_automute_amp_unsol_event,
4262 		.setup = alc880_lg_lw_setup,
4263 		.init_hook = alc_automute_amp,
4264 	},
4265 	[ALC880_MEDION_RIM] = {
4266 		.mixers = { alc880_medion_rim_mixer },
4267 		.init_verbs = { alc880_volume_init_verbs,
4268 				alc880_medion_rim_init_verbs,
4269 				alc_gpio2_init_verbs },
4270 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4271 		.dac_nids = alc880_dac_nids,
4272 		.dig_out_nid = ALC880_DIGOUT_NID,
4273 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4274 		.channel_mode = alc880_2_jack_modes,
4275 		.input_mux = &alc880_medion_rim_capture_source,
4276 		.unsol_event = alc880_medion_rim_unsol_event,
4277 		.setup = alc880_medion_rim_setup,
4278 		.init_hook = alc880_medion_rim_automute,
4279 	},
4280 #ifdef CONFIG_SND_DEBUG
4281 	[ALC880_TEST] = {
4282 		.mixers = { alc880_test_mixer },
4283 		.init_verbs = { alc880_test_init_verbs },
4284 		.num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4285 		.dac_nids = alc880_test_dac_nids,
4286 		.dig_out_nid = ALC880_DIGOUT_NID,
4287 		.num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4288 		.channel_mode = alc880_test_modes,
4289 		.input_mux = &alc880_test_capture_source,
4290 	},
4291 #endif
4292 };
4293 
4294 /*
4295  * Automatic parse of I/O pins from the BIOS configuration
4296  */
4297 
4298 enum {
4299 	ALC_CTL_WIDGET_VOL,
4300 	ALC_CTL_WIDGET_MUTE,
4301 	ALC_CTL_BIND_MUTE,
4302 };
4303 static struct snd_kcontrol_new alc880_control_templates[] = {
4304 	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4305 	HDA_CODEC_MUTE(NULL, 0, 0, 0),
4306 	HDA_BIND_MUTE(NULL, 0, 0, 0),
4307 };
4308 
4309 /* add dynamic controls */
4310 static int add_control(struct alc_spec *spec, int type, const char *name,
4311 		       unsigned long val)
4312 {
4313 	struct snd_kcontrol_new *knew;
4314 
4315 	snd_array_init(&spec->kctls, sizeof(*knew), 32);
4316 	knew = snd_array_new(&spec->kctls);
4317 	if (!knew)
4318 		return -ENOMEM;
4319 	*knew = alc880_control_templates[type];
4320 	knew->name = kstrdup(name, GFP_KERNEL);
4321 	if (!knew->name)
4322 		return -ENOMEM;
4323 	knew->private_value = val;
4324 	return 0;
4325 }
4326 
4327 #define alc880_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
4328 #define alc880_fixed_pin_idx(nid)	((nid) - 0x14)
4329 #define alc880_is_multi_pin(nid)	((nid) >= 0x18)
4330 #define alc880_multi_pin_idx(nid)	((nid) - 0x18)
4331 #define alc880_idx_to_dac(nid)		((nid) + 0x02)
4332 #define alc880_dac_to_idx(nid)		((nid) - 0x02)
4333 #define alc880_idx_to_mixer(nid)	((nid) + 0x0c)
4334 #define alc880_idx_to_selector(nid)	((nid) + 0x10)
4335 #define ALC880_PIN_CD_NID		0x1c
4336 
4337 /* fill in the dac_nids table from the parsed pin configuration */
4338 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4339 				     const struct auto_pin_cfg *cfg)
4340 {
4341 	hda_nid_t nid;
4342 	int assigned[4];
4343 	int i, j;
4344 
4345 	memset(assigned, 0, sizeof(assigned));
4346 	spec->multiout.dac_nids = spec->private_dac_nids;
4347 
4348 	/* check the pins hardwired to audio widget */
4349 	for (i = 0; i < cfg->line_outs; i++) {
4350 		nid = cfg->line_out_pins[i];
4351 		if (alc880_is_fixed_pin(nid)) {
4352 			int idx = alc880_fixed_pin_idx(nid);
4353 			spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4354 			assigned[idx] = 1;
4355 		}
4356 	}
4357 	/* left pins can be connect to any audio widget */
4358 	for (i = 0; i < cfg->line_outs; i++) {
4359 		nid = cfg->line_out_pins[i];
4360 		if (alc880_is_fixed_pin(nid))
4361 			continue;
4362 		/* search for an empty channel */
4363 		for (j = 0; j < cfg->line_outs; j++) {
4364 			if (!assigned[j]) {
4365 				spec->multiout.dac_nids[i] =
4366 					alc880_idx_to_dac(j);
4367 				assigned[j] = 1;
4368 				break;
4369 			}
4370 		}
4371 	}
4372 	spec->multiout.num_dacs = cfg->line_outs;
4373 	return 0;
4374 }
4375 
4376 /* add playback controls from the parsed DAC table */
4377 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4378 					     const struct auto_pin_cfg *cfg)
4379 {
4380 	char name[32];
4381 	static const char *chname[4] = {
4382 		"Front", "Surround", NULL /*CLFE*/, "Side"
4383 	};
4384 	hda_nid_t nid;
4385 	int i, err;
4386 
4387 	for (i = 0; i < cfg->line_outs; i++) {
4388 		if (!spec->multiout.dac_nids[i])
4389 			continue;
4390 		nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4391 		if (i == 2) {
4392 			/* Center/LFE */
4393 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
4394 					  "Center Playback Volume",
4395 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4396 							      HDA_OUTPUT));
4397 			if (err < 0)
4398 				return err;
4399 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
4400 					  "LFE Playback Volume",
4401 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4402 							      HDA_OUTPUT));
4403 			if (err < 0)
4404 				return err;
4405 			err = add_control(spec, ALC_CTL_BIND_MUTE,
4406 					  "Center Playback Switch",
4407 					  HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4408 							      HDA_INPUT));
4409 			if (err < 0)
4410 				return err;
4411 			err = add_control(spec, ALC_CTL_BIND_MUTE,
4412 					  "LFE Playback Switch",
4413 					  HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4414 							      HDA_INPUT));
4415 			if (err < 0)
4416 				return err;
4417 		} else {
4418 			const char *pfx;
4419 			if (cfg->line_outs == 1 &&
4420 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4421 				pfx = "Speaker";
4422 			else
4423 				pfx = chname[i];
4424 			sprintf(name, "%s Playback Volume", pfx);
4425 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4426 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4427 							      HDA_OUTPUT));
4428 			if (err < 0)
4429 				return err;
4430 			sprintf(name, "%s Playback Switch", pfx);
4431 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4432 					  HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4433 							      HDA_INPUT));
4434 			if (err < 0)
4435 				return err;
4436 		}
4437 	}
4438 	return 0;
4439 }
4440 
4441 /* add playback controls for speaker and HP outputs */
4442 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4443 					const char *pfx)
4444 {
4445 	hda_nid_t nid;
4446 	int err;
4447 	char name[32];
4448 
4449 	if (!pin)
4450 		return 0;
4451 
4452 	if (alc880_is_fixed_pin(pin)) {
4453 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4454 		/* specify the DAC as the extra output */
4455 		if (!spec->multiout.hp_nid)
4456 			spec->multiout.hp_nid = nid;
4457 		else
4458 			spec->multiout.extra_out_nid[0] = nid;
4459 		/* control HP volume/switch on the output mixer amp */
4460 		nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4461 		sprintf(name, "%s Playback Volume", pfx);
4462 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4463 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4464 		if (err < 0)
4465 			return err;
4466 		sprintf(name, "%s Playback Switch", pfx);
4467 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4468 				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4469 		if (err < 0)
4470 			return err;
4471 	} else if (alc880_is_multi_pin(pin)) {
4472 		/* set manual connection */
4473 		/* we have only a switch on HP-out PIN */
4474 		sprintf(name, "%s Playback Switch", pfx);
4475 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4476 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4477 		if (err < 0)
4478 			return err;
4479 	}
4480 	return 0;
4481 }
4482 
4483 /* create input playback/capture controls for the given pin */
4484 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4485 			    const char *ctlname,
4486 			    int idx, hda_nid_t mix_nid)
4487 {
4488 	char name[32];
4489 	int err;
4490 
4491 	sprintf(name, "%s Playback Volume", ctlname);
4492 	err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4493 			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4494 	if (err < 0)
4495 		return err;
4496 	sprintf(name, "%s Playback Switch", ctlname);
4497 	err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4498 			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4499 	if (err < 0)
4500 		return err;
4501 	return 0;
4502 }
4503 
4504 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4505 {
4506 	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4507 	return (pincap & AC_PINCAP_IN) != 0;
4508 }
4509 
4510 /* create playback/capture controls for input pins */
4511 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4512 				      const struct auto_pin_cfg *cfg,
4513 				      hda_nid_t mixer,
4514 				      hda_nid_t cap1, hda_nid_t cap2)
4515 {
4516 	struct alc_spec *spec = codec->spec;
4517 	struct hda_input_mux *imux = &spec->private_imux[0];
4518 	int i, err, idx;
4519 
4520 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4521 		hda_nid_t pin;
4522 
4523 		pin = cfg->input_pins[i];
4524 		if (!alc_is_input_pin(codec, pin))
4525 			continue;
4526 
4527 		if (mixer) {
4528 			idx = get_connection_index(codec, mixer, pin);
4529 			if (idx >= 0) {
4530 				err = new_analog_input(spec, pin,
4531 						       auto_pin_cfg_labels[i],
4532 						       idx, mixer);
4533 				if (err < 0)
4534 					return err;
4535 			}
4536 		}
4537 
4538 		if (!cap1)
4539 			continue;
4540 		idx = get_connection_index(codec, cap1, pin);
4541 		if (idx < 0 && cap2)
4542 			idx = get_connection_index(codec, cap2, pin);
4543 		if (idx >= 0) {
4544 			imux->items[imux->num_items].label =
4545 				auto_pin_cfg_labels[i];
4546 			imux->items[imux->num_items].index = idx;
4547 			imux->num_items++;
4548 		}
4549 	}
4550 	return 0;
4551 }
4552 
4553 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4554 						const struct auto_pin_cfg *cfg)
4555 {
4556 	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4557 }
4558 
4559 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4560 			       unsigned int pin_type)
4561 {
4562 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4563 			    pin_type);
4564 	/* unmute pin */
4565 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4566 			    AMP_OUT_UNMUTE);
4567 }
4568 
4569 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4570 					      hda_nid_t nid, int pin_type,
4571 					      int dac_idx)
4572 {
4573 	alc_set_pin_output(codec, nid, pin_type);
4574 	/* need the manual connection? */
4575 	if (alc880_is_multi_pin(nid)) {
4576 		struct alc_spec *spec = codec->spec;
4577 		int idx = alc880_multi_pin_idx(nid);
4578 		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4579 				    AC_VERB_SET_CONNECT_SEL,
4580 				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4581 	}
4582 }
4583 
4584 static int get_pin_type(int line_out_type)
4585 {
4586 	if (line_out_type == AUTO_PIN_HP_OUT)
4587 		return PIN_HP;
4588 	else
4589 		return PIN_OUT;
4590 }
4591 
4592 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4593 {
4594 	struct alc_spec *spec = codec->spec;
4595 	int i;
4596 
4597 	for (i = 0; i < spec->autocfg.line_outs; i++) {
4598 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
4599 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
4600 		alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4601 	}
4602 }
4603 
4604 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4605 {
4606 	struct alc_spec *spec = codec->spec;
4607 	hda_nid_t pin;
4608 
4609 	pin = spec->autocfg.speaker_pins[0];
4610 	if (pin) /* connect to front */
4611 		alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4612 	pin = spec->autocfg.hp_pins[0];
4613 	if (pin) /* connect to front */
4614 		alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4615 }
4616 
4617 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4618 {
4619 	struct alc_spec *spec = codec->spec;
4620 	int i;
4621 
4622 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4623 		hda_nid_t nid = spec->autocfg.input_pins[i];
4624 		if (alc_is_input_pin(codec, nid)) {
4625 			alc_set_input_pin(codec, nid, i);
4626 			if (nid != ALC880_PIN_CD_NID &&
4627 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4628 				snd_hda_codec_write(codec, nid, 0,
4629 						    AC_VERB_SET_AMP_GAIN_MUTE,
4630 						    AMP_OUT_MUTE);
4631 		}
4632 	}
4633 }
4634 
4635 /* parse the BIOS configuration and set up the alc_spec */
4636 /* return 1 if successful, 0 if the proper config is not found,
4637  * or a negative error code
4638  */
4639 static int alc880_parse_auto_config(struct hda_codec *codec)
4640 {
4641 	struct alc_spec *spec = codec->spec;
4642 	int i, err;
4643 	static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4644 
4645 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4646 					   alc880_ignore);
4647 	if (err < 0)
4648 		return err;
4649 	if (!spec->autocfg.line_outs)
4650 		return 0; /* can't find valid BIOS pin config */
4651 
4652 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4653 	if (err < 0)
4654 		return err;
4655 	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4656 	if (err < 0)
4657 		return err;
4658 	err = alc880_auto_create_extra_out(spec,
4659 					   spec->autocfg.speaker_pins[0],
4660 					   "Speaker");
4661 	if (err < 0)
4662 		return err;
4663 	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4664 					   "Headphone");
4665 	if (err < 0)
4666 		return err;
4667 	err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4668 	if (err < 0)
4669 		return err;
4670 
4671 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4672 
4673 	/* check multiple SPDIF-out (for recent codecs) */
4674 	for (i = 0; i < spec->autocfg.dig_outs; i++) {
4675 		hda_nid_t dig_nid;
4676 		err = snd_hda_get_connections(codec,
4677 					      spec->autocfg.dig_out_pins[i],
4678 					      &dig_nid, 1);
4679 		if (err < 0)
4680 			continue;
4681 		if (!i)
4682 			spec->multiout.dig_out_nid = dig_nid;
4683 		else {
4684 			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4685 			spec->slave_dig_outs[i - 1] = dig_nid;
4686 			if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4687 				break;
4688 		}
4689 	}
4690 	if (spec->autocfg.dig_in_pin)
4691 		spec->dig_in_nid = ALC880_DIGIN_NID;
4692 
4693 	if (spec->kctls.list)
4694 		add_mixer(spec, spec->kctls.list);
4695 
4696 	add_verb(spec, alc880_volume_init_verbs);
4697 
4698 	spec->num_mux_defs = 1;
4699 	spec->input_mux = &spec->private_imux[0];
4700 
4701 	alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4702 
4703 	return 1;
4704 }
4705 
4706 /* additional initialization for auto-configuration model */
4707 static void alc880_auto_init(struct hda_codec *codec)
4708 {
4709 	struct alc_spec *spec = codec->spec;
4710 	alc880_auto_init_multi_out(codec);
4711 	alc880_auto_init_extra_out(codec);
4712 	alc880_auto_init_analog_input(codec);
4713 	if (spec->unsol_event)
4714 		alc_inithook(codec);
4715 }
4716 
4717 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4718  * one of two digital mic pins, e.g. on ALC272
4719  */
4720 static void fixup_automic_adc(struct hda_codec *codec)
4721 {
4722 	struct alc_spec *spec = codec->spec;
4723 	int i;
4724 
4725 	for (i = 0; i < spec->num_adc_nids; i++) {
4726 		hda_nid_t cap = spec->capsrc_nids ?
4727 			spec->capsrc_nids[i] : spec->adc_nids[i];
4728 		int iidx, eidx;
4729 
4730 		iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4731 		if (iidx < 0)
4732 			continue;
4733 		eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4734 		if (eidx < 0)
4735 			continue;
4736 		spec->int_mic.mux_idx = iidx;
4737 		spec->ext_mic.mux_idx = eidx;
4738 		if (spec->capsrc_nids)
4739 			spec->capsrc_nids += i;
4740 		spec->adc_nids += i;
4741 		spec->num_adc_nids = 1;
4742 		return;
4743 	}
4744 	snd_printd(KERN_INFO "hda_codec: %s: "
4745 		   "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4746 		   codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4747 	spec->auto_mic = 0; /* disable auto-mic to be sure */
4748 }
4749 
4750 static void set_capture_mixer(struct hda_codec *codec)
4751 {
4752 	struct alc_spec *spec = codec->spec;
4753 	static struct snd_kcontrol_new *caps[2][3] = {
4754 		{ alc_capture_mixer_nosrc1,
4755 		  alc_capture_mixer_nosrc2,
4756 		  alc_capture_mixer_nosrc3 },
4757 		{ alc_capture_mixer1,
4758 		  alc_capture_mixer2,
4759 		  alc_capture_mixer3 },
4760 	};
4761 	if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4762 		int mux;
4763 		if (spec->auto_mic) {
4764 			mux = 0;
4765 			fixup_automic_adc(codec);
4766 		} else if (spec->input_mux && spec->input_mux->num_items > 1)
4767 			mux = 1;
4768 		else
4769 			mux = 0;
4770 		spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4771 	}
4772 }
4773 
4774 #define set_beep_amp(spec, nid, idx, dir) \
4775 	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4776 
4777 /*
4778  * OK, here we have finally the patch for ALC880
4779  */
4780 
4781 static int patch_alc880(struct hda_codec *codec)
4782 {
4783 	struct alc_spec *spec;
4784 	int board_config;
4785 	int err;
4786 
4787 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4788 	if (spec == NULL)
4789 		return -ENOMEM;
4790 
4791 	codec->spec = spec;
4792 
4793 	board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4794 						  alc880_models,
4795 						  alc880_cfg_tbl);
4796 	if (board_config < 0) {
4797 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4798 		       codec->chip_name);
4799 		board_config = ALC880_AUTO;
4800 	}
4801 
4802 	if (board_config == ALC880_AUTO) {
4803 		/* automatic parse from the BIOS config */
4804 		err = alc880_parse_auto_config(codec);
4805 		if (err < 0) {
4806 			alc_free(codec);
4807 			return err;
4808 		} else if (!err) {
4809 			printk(KERN_INFO
4810 			       "hda_codec: Cannot set up configuration "
4811 			       "from BIOS.  Using 3-stack mode...\n");
4812 			board_config = ALC880_3ST;
4813 		}
4814 	}
4815 
4816 	err = snd_hda_attach_beep_device(codec, 0x1);
4817 	if (err < 0) {
4818 		alc_free(codec);
4819 		return err;
4820 	}
4821 
4822 	if (board_config != ALC880_AUTO)
4823 		setup_preset(codec, &alc880_presets[board_config]);
4824 
4825 	spec->stream_analog_playback = &alc880_pcm_analog_playback;
4826 	spec->stream_analog_capture = &alc880_pcm_analog_capture;
4827 	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4828 
4829 	spec->stream_digital_playback = &alc880_pcm_digital_playback;
4830 	spec->stream_digital_capture = &alc880_pcm_digital_capture;
4831 
4832 	if (!spec->adc_nids && spec->input_mux) {
4833 		/* check whether NID 0x07 is valid */
4834 		unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4835 		/* get type */
4836 		wcap = get_wcaps_type(wcap);
4837 		if (wcap != AC_WID_AUD_IN) {
4838 			spec->adc_nids = alc880_adc_nids_alt;
4839 			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4840 		} else {
4841 			spec->adc_nids = alc880_adc_nids;
4842 			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4843 		}
4844 	}
4845 	set_capture_mixer(codec);
4846 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4847 
4848 	spec->vmaster_nid = 0x0c;
4849 
4850 	codec->patch_ops = alc_patch_ops;
4851 	if (board_config == ALC880_AUTO)
4852 		spec->init_hook = alc880_auto_init;
4853 #ifdef CONFIG_SND_HDA_POWER_SAVE
4854 	if (!spec->loopback.amplist)
4855 		spec->loopback.amplist = alc880_loopbacks;
4856 #endif
4857 	codec->proc_widget_hook = print_realtek_coef;
4858 
4859 	return 0;
4860 }
4861 
4862 
4863 /*
4864  * ALC260 support
4865  */
4866 
4867 static hda_nid_t alc260_dac_nids[1] = {
4868 	/* front */
4869 	0x02,
4870 };
4871 
4872 static hda_nid_t alc260_adc_nids[1] = {
4873 	/* ADC0 */
4874 	0x04,
4875 };
4876 
4877 static hda_nid_t alc260_adc_nids_alt[1] = {
4878 	/* ADC1 */
4879 	0x05,
4880 };
4881 
4882 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4883  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4884  */
4885 static hda_nid_t alc260_dual_adc_nids[2] = {
4886 	/* ADC0, ADC1 */
4887 	0x04, 0x05
4888 };
4889 
4890 #define ALC260_DIGOUT_NID	0x03
4891 #define ALC260_DIGIN_NID	0x06
4892 
4893 static struct hda_input_mux alc260_capture_source = {
4894 	.num_items = 4,
4895 	.items = {
4896 		{ "Mic", 0x0 },
4897 		{ "Front Mic", 0x1 },
4898 		{ "Line", 0x2 },
4899 		{ "CD", 0x4 },
4900 	},
4901 };
4902 
4903 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4904  * headphone jack and the internal CD lines since these are the only pins at
4905  * which audio can appear.  For flexibility, also allow the option of
4906  * recording the mixer output on the second ADC (ADC0 doesn't have a
4907  * connection to the mixer output).
4908  */
4909 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4910 	{
4911 		.num_items = 3,
4912 		.items = {
4913 			{ "Mic/Line", 0x0 },
4914 			{ "CD", 0x4 },
4915 			{ "Headphone", 0x2 },
4916 		},
4917 	},
4918 	{
4919 		.num_items = 4,
4920 		.items = {
4921 			{ "Mic/Line", 0x0 },
4922 			{ "CD", 0x4 },
4923 			{ "Headphone", 0x2 },
4924 			{ "Mixer", 0x5 },
4925 		},
4926 	},
4927 
4928 };
4929 
4930 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4931  * the Fujitsu S702x, but jacks are marked differently.
4932  */
4933 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4934 	{
4935 		.num_items = 4,
4936 		.items = {
4937 			{ "Mic", 0x0 },
4938 			{ "Line", 0x2 },
4939 			{ "CD", 0x4 },
4940 			{ "Headphone", 0x5 },
4941 		},
4942 	},
4943 	{
4944 		.num_items = 5,
4945 		.items = {
4946 			{ "Mic", 0x0 },
4947 			{ "Line", 0x2 },
4948 			{ "CD", 0x4 },
4949 			{ "Headphone", 0x6 },
4950 			{ "Mixer", 0x5 },
4951 		},
4952 	},
4953 };
4954 
4955 /* Maxdata Favorit 100XS */
4956 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4957 	{
4958 		.num_items = 2,
4959 		.items = {
4960 			{ "Line/Mic", 0x0 },
4961 			{ "CD", 0x4 },
4962 		},
4963 	},
4964 	{
4965 		.num_items = 3,
4966 		.items = {
4967 			{ "Line/Mic", 0x0 },
4968 			{ "CD", 0x4 },
4969 			{ "Mixer", 0x5 },
4970 		},
4971 	},
4972 };
4973 
4974 /*
4975  * This is just place-holder, so there's something for alc_build_pcms to look
4976  * at when it calculates the maximum number of channels. ALC260 has no mixer
4977  * element which allows changing the channel mode, so the verb list is
4978  * never used.
4979  */
4980 static struct hda_channel_mode alc260_modes[1] = {
4981 	{ 2, NULL },
4982 };
4983 
4984 
4985 /* Mixer combinations
4986  *
4987  * basic: base_output + input + pc_beep + capture
4988  * HP: base_output + input + capture_alt
4989  * HP_3013: hp_3013 + input + capture
4990  * fujitsu: fujitsu + capture
4991  * acer: acer + capture
4992  */
4993 
4994 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4995 	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4996 	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4997 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4998 	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4999 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5000 	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5001 	{ } /* end */
5002 };
5003 
5004 static struct snd_kcontrol_new alc260_input_mixer[] = {
5005 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5006 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5007 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5008 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5009 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5010 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5011 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5012 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5013 	{ } /* end */
5014 };
5015 
5016 /* update HP, line and mono out pins according to the master switch */
5017 static void alc260_hp_master_update(struct hda_codec *codec,
5018 				    hda_nid_t hp, hda_nid_t line,
5019 				    hda_nid_t mono)
5020 {
5021 	struct alc_spec *spec = codec->spec;
5022 	unsigned int val = spec->master_sw ? PIN_HP : 0;
5023 	/* change HP and line-out pins */
5024 	snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5025 			    val);
5026 	snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5027 			    val);
5028 	/* mono (speaker) depending on the HP jack sense */
5029 	val = (val && !spec->jack_present) ? PIN_OUT : 0;
5030 	snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5031 			    val);
5032 }
5033 
5034 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5035 				   struct snd_ctl_elem_value *ucontrol)
5036 {
5037 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5038 	struct alc_spec *spec = codec->spec;
5039 	*ucontrol->value.integer.value = spec->master_sw;
5040 	return 0;
5041 }
5042 
5043 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5044 				   struct snd_ctl_elem_value *ucontrol)
5045 {
5046 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5047 	struct alc_spec *spec = codec->spec;
5048 	int val = !!*ucontrol->value.integer.value;
5049 	hda_nid_t hp, line, mono;
5050 
5051 	if (val == spec->master_sw)
5052 		return 0;
5053 	spec->master_sw = val;
5054 	hp = (kcontrol->private_value >> 16) & 0xff;
5055 	line = (kcontrol->private_value >> 8) & 0xff;
5056 	mono = kcontrol->private_value & 0xff;
5057 	alc260_hp_master_update(codec, hp, line, mono);
5058 	return 1;
5059 }
5060 
5061 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5062 	{
5063 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5064 		.name = "Master Playback Switch",
5065 		.info = snd_ctl_boolean_mono_info,
5066 		.get = alc260_hp_master_sw_get,
5067 		.put = alc260_hp_master_sw_put,
5068 		.private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5069 	},
5070 	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5071 	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5072 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5073 	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5074 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5075 			      HDA_OUTPUT),
5076 	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5077 	{ } /* end */
5078 };
5079 
5080 static struct hda_verb alc260_hp_unsol_verbs[] = {
5081 	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5082 	{},
5083 };
5084 
5085 static void alc260_hp_automute(struct hda_codec *codec)
5086 {
5087 	struct alc_spec *spec = codec->spec;
5088 	unsigned int present;
5089 
5090 	present = snd_hda_codec_read(codec, 0x10, 0,
5091 				     AC_VERB_GET_PIN_SENSE, 0);
5092 	spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
5093 	alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5094 }
5095 
5096 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5097 {
5098 	if ((res >> 26) == ALC880_HP_EVENT)
5099 		alc260_hp_automute(codec);
5100 }
5101 
5102 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5103 	{
5104 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5105 		.name = "Master Playback Switch",
5106 		.info = snd_ctl_boolean_mono_info,
5107 		.get = alc260_hp_master_sw_get,
5108 		.put = alc260_hp_master_sw_put,
5109 		.private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5110 	},
5111 	HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5112 	HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5113 	HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5114 	HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5115 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5116 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5117 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5118 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5119 	{ } /* end */
5120 };
5121 
5122 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5123 	.ops = &snd_hda_bind_vol,
5124 	.values = {
5125 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5126 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5127 		HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5128 		0
5129 	},
5130 };
5131 
5132 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5133 	.ops = &snd_hda_bind_sw,
5134 	.values = {
5135 		HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5136 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5137 		0
5138 	},
5139 };
5140 
5141 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5142 	HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5143 	HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5144 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5145 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5146 	{ } /* end */
5147 };
5148 
5149 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5150 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5151 	{},
5152 };
5153 
5154 static void alc260_hp_3013_automute(struct hda_codec *codec)
5155 {
5156 	struct alc_spec *spec = codec->spec;
5157 	unsigned int present;
5158 
5159 	present = snd_hda_codec_read(codec, 0x15, 0,
5160 				     AC_VERB_GET_PIN_SENSE, 0);
5161 	spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
5162 	alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5163 }
5164 
5165 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5166 				       unsigned int res)
5167 {
5168 	if ((res >> 26) == ALC880_HP_EVENT)
5169 		alc260_hp_3013_automute(codec);
5170 }
5171 
5172 static void alc260_hp_3012_automute(struct hda_codec *codec)
5173 {
5174 	unsigned int present, bits;
5175 
5176 	present = snd_hda_codec_read(codec, 0x10, 0,
5177 			AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
5178 
5179 	bits = present ? 0 : PIN_OUT;
5180 	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5181 			    bits);
5182 	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5183 			    bits);
5184 	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5185 			    bits);
5186 }
5187 
5188 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5189 				       unsigned int res)
5190 {
5191 	if ((res >> 26) == ALC880_HP_EVENT)
5192 		alc260_hp_3012_automute(codec);
5193 }
5194 
5195 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5196  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5197  */
5198 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5199 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5200 	HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5201 	ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5202 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5203 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5204 	HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5205 	HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5206 	ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5207 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5208 	HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5209 	{ } /* end */
5210 };
5211 
5212 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5213  * versions of the ALC260 don't act on requests to enable mic bias from NID
5214  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5215  * datasheet doesn't mention this restriction.  At this stage it's not clear
5216  * whether this behaviour is intentional or is a hardware bug in chip
5217  * revisions available in early 2006.  Therefore for now allow the
5218  * "Headphone Jack Mode" control to span all choices, but if it turns out
5219  * that the lack of mic bias for this NID is intentional we could change the
5220  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5221  *
5222  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5223  * don't appear to make the mic bias available from the "line" jack, even
5224  * though the NID used for this jack (0x14) can supply it.  The theory is
5225  * that perhaps Acer have included blocking capacitors between the ALC260
5226  * and the output jack.  If this turns out to be the case for all such
5227  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5228  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5229  *
5230  * The C20x Tablet series have a mono internal speaker which is controlled
5231  * via the chip's Mono sum widget and pin complex, so include the necessary
5232  * controls for such models.  On models without a "mono speaker" the control
5233  * won't do anything.
5234  */
5235 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5236 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5237 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5238 	ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5239 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5240 			      HDA_OUTPUT),
5241 	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5242 			   HDA_INPUT),
5243 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5244 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5245 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5246 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5247 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5248 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5249 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5250 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5251 	{ } /* end */
5252 };
5253 
5254 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5255  */
5256 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5257 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5258 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5259 	ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5260 	HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5261 	HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5262 	ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5263 	{ } /* end */
5264 };
5265 
5266 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5267  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5268  */
5269 static struct snd_kcontrol_new alc260_will_mixer[] = {
5270 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5271 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5272 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5273 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5274 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5275 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5276 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5277 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5278 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5279 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5280 	{ } /* end */
5281 };
5282 
5283 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5284  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5285  */
5286 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5287 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5288 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5289 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5290 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5291 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5292 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5293 	HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5294 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5295 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5296 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5297 	{ } /* end */
5298 };
5299 
5300 /*
5301  * initialization verbs
5302  */
5303 static struct hda_verb alc260_init_verbs[] = {
5304 	/* Line In pin widget for input */
5305 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5306 	/* CD pin widget for input */
5307 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5308 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
5309 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5310 	/* Mic2 (front panel) pin widget for input and vref at 80% */
5311 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5312 	/* LINE-2 is used for line-out in rear */
5313 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5314 	/* select line-out */
5315 	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5316 	/* LINE-OUT pin */
5317 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5318 	/* enable HP */
5319 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5320 	/* enable Mono */
5321 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5322 	/* mute capture amp left and right */
5323 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5324 	/* set connection select to line in (default select for this ADC) */
5325 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5326 	/* mute capture amp left and right */
5327 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5328 	/* set connection select to line in (default select for this ADC) */
5329 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5330 	/* set vol=0 Line-Out mixer amp left and right */
5331 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5332 	/* unmute pin widget amp left and right (no gain on this amp) */
5333 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5334 	/* set vol=0 HP mixer amp left and right */
5335 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5336 	/* unmute pin widget amp left and right (no gain on this amp) */
5337 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5338 	/* set vol=0 Mono mixer amp left and right */
5339 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5340 	/* unmute pin widget amp left and right (no gain on this amp) */
5341 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5342 	/* unmute LINE-2 out pin */
5343 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5344 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5345 	 * Line In 2 = 0x03
5346 	 */
5347 	/* mute analog inputs */
5348 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5349 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5350 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5351 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5352 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5353 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5354 	/* mute Front out path */
5355 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5356 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5357 	/* mute Headphone out path */
5358 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5359 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5360 	/* mute Mono out path */
5361 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5362 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5363 	{ }
5364 };
5365 
5366 #if 0 /* should be identical with alc260_init_verbs? */
5367 static struct hda_verb alc260_hp_init_verbs[] = {
5368 	/* Headphone and output */
5369 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5370 	/* mono output */
5371 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5372 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
5373 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5374 	/* Mic2 (front panel) pin widget for input and vref at 80% */
5375 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5376 	/* Line In pin widget for input */
5377 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5378 	/* Line-2 pin widget for output */
5379 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5380 	/* CD pin widget for input */
5381 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5382 	/* unmute amp left and right */
5383 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5384 	/* set connection select to line in (default select for this ADC) */
5385 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5386 	/* unmute Line-Out mixer amp left and right (volume = 0) */
5387 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5388 	/* mute pin widget amp left and right (no gain on this amp) */
5389 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5390 	/* unmute HP mixer amp left and right (volume = 0) */
5391 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5392 	/* mute pin widget amp left and right (no gain on this amp) */
5393 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5394 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5395 	 * Line In 2 = 0x03
5396 	 */
5397 	/* mute analog inputs */
5398 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5399 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5400 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5401 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5402 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5403 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5404 	/* Unmute Front out path */
5405 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5406 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5407 	/* Unmute Headphone out path */
5408 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5409 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5410 	/* Unmute Mono out path */
5411 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5412 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5413 	{ }
5414 };
5415 #endif
5416 
5417 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5418 	/* Line out and output */
5419 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5420 	/* mono output */
5421 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5422 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
5423 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5424 	/* Mic2 (front panel) pin widget for input and vref at 80% */
5425 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5426 	/* Line In pin widget for input */
5427 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5428 	/* Headphone pin widget for output */
5429 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5430 	/* CD pin widget for input */
5431 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5432 	/* unmute amp left and right */
5433 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5434 	/* set connection select to line in (default select for this ADC) */
5435 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5436 	/* unmute Line-Out mixer amp left and right (volume = 0) */
5437 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5438 	/* mute pin widget amp left and right (no gain on this amp) */
5439 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5440 	/* unmute HP mixer amp left and right (volume = 0) */
5441 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5442 	/* mute pin widget amp left and right (no gain on this amp) */
5443 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5444 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5445 	 * Line In 2 = 0x03
5446 	 */
5447 	/* mute analog inputs */
5448 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5449 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5450 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5451 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5452 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5453 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5454 	/* Unmute Front out path */
5455 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5456 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5457 	/* Unmute Headphone out path */
5458 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5459 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5460 	/* Unmute Mono out path */
5461 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5462 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5463 	{ }
5464 };
5465 
5466 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5467  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5468  * audio = 0x16, internal speaker = 0x10.
5469  */
5470 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5471 	/* Disable all GPIOs */
5472 	{0x01, AC_VERB_SET_GPIO_MASK, 0},
5473 	/* Internal speaker is connected to headphone pin */
5474 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5475 	/* Headphone/Line-out jack connects to Line1 pin; make it an output */
5476 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5477 	/* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5478 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5479 	/* Ensure all other unused pins are disabled and muted. */
5480 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5481 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5482 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5483 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5484 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5485 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5486 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5487 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5488 
5489 	/* Disable digital (SPDIF) pins */
5490 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5491 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5492 
5493 	/* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5494 	 * when acting as an output.
5495 	 */
5496 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5497 
5498 	/* Start with output sum widgets muted and their output gains at min */
5499 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5500 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5501 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5502 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5503 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5504 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5505 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5506 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5507 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5508 
5509 	/* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5510 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5511 	/* Unmute Line1 pin widget output buffer since it starts as an output.
5512 	 * If the pin mode is changed by the user the pin mode control will
5513 	 * take care of enabling the pin's input/output buffers as needed.
5514 	 * Therefore there's no need to enable the input buffer at this
5515 	 * stage.
5516 	 */
5517 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5518 	/* Unmute input buffer of pin widget used for Line-in (no equiv
5519 	 * mixer ctrl)
5520 	 */
5521 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5522 
5523 	/* Mute capture amp left and right */
5524 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5525 	/* Set ADC connection select to match default mixer setting - line
5526 	 * in (on mic1 pin)
5527 	 */
5528 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5529 
5530 	/* Do the same for the second ADC: mute capture input amp and
5531 	 * set ADC connection to line in (on mic1 pin)
5532 	 */
5533 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5534 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5535 
5536 	/* Mute all inputs to mixer widget (even unconnected ones) */
5537 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5538 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5539 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5540 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5541 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5542 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5543 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5544 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5545 
5546 	{ }
5547 };
5548 
5549 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5550  * similar laptops (adapted from Fujitsu init verbs).
5551  */
5552 static struct hda_verb alc260_acer_init_verbs[] = {
5553 	/* On TravelMate laptops, GPIO 0 enables the internal speaker and
5554 	 * the headphone jack.  Turn this on and rely on the standard mute
5555 	 * methods whenever the user wants to turn these outputs off.
5556 	 */
5557 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5558 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5559 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5560 	/* Internal speaker/Headphone jack is connected to Line-out pin */
5561 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5562 	/* Internal microphone/Mic jack is connected to Mic1 pin */
5563 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5564 	/* Line In jack is connected to Line1 pin */
5565 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5566 	/* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5567 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5568 	/* Ensure all other unused pins are disabled and muted. */
5569 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5570 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5571 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5572 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5573 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5574 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5575 	/* Disable digital (SPDIF) pins */
5576 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5577 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5578 
5579 	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5580 	 * bus when acting as outputs.
5581 	 */
5582 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5583 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5584 
5585 	/* Start with output sum widgets muted and their output gains at min */
5586 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5587 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5588 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5589 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5590 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5591 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5592 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5593 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5594 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5595 
5596 	/* Unmute Line-out pin widget amp left and right
5597 	 * (no equiv mixer ctrl)
5598 	 */
5599 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5600 	/* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5601 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5602 	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
5603 	 * inputs. If the pin mode is changed by the user the pin mode control
5604 	 * will take care of enabling the pin's input/output buffers as needed.
5605 	 * Therefore there's no need to enable the input buffer at this
5606 	 * stage.
5607 	 */
5608 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5609 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5610 
5611 	/* Mute capture amp left and right */
5612 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5613 	/* Set ADC connection select to match default mixer setting - mic
5614 	 * (on mic1 pin)
5615 	 */
5616 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5617 
5618 	/* Do similar with the second ADC: mute capture input amp and
5619 	 * set ADC connection to mic to match ALSA's default state.
5620 	 */
5621 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5622 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5623 
5624 	/* Mute all inputs to mixer widget (even unconnected ones) */
5625 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5626 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5627 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5628 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5629 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5630 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5631 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5632 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5633 
5634 	{ }
5635 };
5636 
5637 /* Initialisation sequence for Maxdata Favorit 100XS
5638  * (adapted from Acer init verbs).
5639  */
5640 static struct hda_verb alc260_favorit100_init_verbs[] = {
5641 	/* GPIO 0 enables the output jack.
5642 	 * Turn this on and rely on the standard mute
5643 	 * methods whenever the user wants to turn these outputs off.
5644 	 */
5645 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5646 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5647 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5648 	/* Line/Mic input jack is connected to Mic1 pin */
5649 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5650 	/* Ensure all other unused pins are disabled and muted. */
5651 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5652 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5653 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5654 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5655 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5656 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5657 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5658 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5659 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5660 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5661 	/* Disable digital (SPDIF) pins */
5662 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5663 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5664 
5665 	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5666 	 * bus when acting as outputs.
5667 	 */
5668 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5669 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5670 
5671 	/* Start with output sum widgets muted and their output gains at min */
5672 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5673 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5674 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5675 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5676 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5677 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5678 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5679 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5680 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5681 
5682 	/* Unmute Line-out pin widget amp left and right
5683 	 * (no equiv mixer ctrl)
5684 	 */
5685 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5686 	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
5687 	 * inputs. If the pin mode is changed by the user the pin mode control
5688 	 * will take care of enabling the pin's input/output buffers as needed.
5689 	 * Therefore there's no need to enable the input buffer at this
5690 	 * stage.
5691 	 */
5692 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5693 
5694 	/* Mute capture amp left and right */
5695 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5696 	/* Set ADC connection select to match default mixer setting - mic
5697 	 * (on mic1 pin)
5698 	 */
5699 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5700 
5701 	/* Do similar with the second ADC: mute capture input amp and
5702 	 * set ADC connection to mic to match ALSA's default state.
5703 	 */
5704 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5705 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5706 
5707 	/* Mute all inputs to mixer widget (even unconnected ones) */
5708 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5709 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5710 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5711 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5712 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5713 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5714 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5715 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5716 
5717 	{ }
5718 };
5719 
5720 static struct hda_verb alc260_will_verbs[] = {
5721 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5722 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5723 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5724 	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5725 	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5726 	{0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5727 	{}
5728 };
5729 
5730 static struct hda_verb alc260_replacer_672v_verbs[] = {
5731 	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5732 	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5733 	{0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5734 
5735 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5736 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5737 	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5738 
5739 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5740 	{}
5741 };
5742 
5743 /* toggle speaker-output according to the hp-jack state */
5744 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5745 {
5746         unsigned int present;
5747 
5748 	/* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5749         present = snd_hda_codec_read(codec, 0x0f, 0,
5750                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5751 	if (present) {
5752 		snd_hda_codec_write_cache(codec, 0x01, 0,
5753 					  AC_VERB_SET_GPIO_DATA, 1);
5754 		snd_hda_codec_write_cache(codec, 0x0f, 0,
5755 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
5756 					  PIN_HP);
5757 	} else {
5758 		snd_hda_codec_write_cache(codec, 0x01, 0,
5759 					  AC_VERB_SET_GPIO_DATA, 0);
5760 		snd_hda_codec_write_cache(codec, 0x0f, 0,
5761 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
5762 					  PIN_OUT);
5763 	}
5764 }
5765 
5766 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5767                                        unsigned int res)
5768 {
5769         if ((res >> 26) == ALC880_HP_EVENT)
5770                 alc260_replacer_672v_automute(codec);
5771 }
5772 
5773 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5774 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5775 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5776 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5777 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5778 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5779 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5780 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5781 	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5782 	{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5783 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5784 	{}
5785 };
5786 
5787 /* Test configuration for debugging, modelled after the ALC880 test
5788  * configuration.
5789  */
5790 #ifdef CONFIG_SND_DEBUG
5791 static hda_nid_t alc260_test_dac_nids[1] = {
5792 	0x02,
5793 };
5794 static hda_nid_t alc260_test_adc_nids[2] = {
5795 	0x04, 0x05,
5796 };
5797 /* For testing the ALC260, each input MUX needs its own definition since
5798  * the signal assignments are different.  This assumes that the first ADC
5799  * is NID 0x04.
5800  */
5801 static struct hda_input_mux alc260_test_capture_sources[2] = {
5802 	{
5803 		.num_items = 7,
5804 		.items = {
5805 			{ "MIC1 pin", 0x0 },
5806 			{ "MIC2 pin", 0x1 },
5807 			{ "LINE1 pin", 0x2 },
5808 			{ "LINE2 pin", 0x3 },
5809 			{ "CD pin", 0x4 },
5810 			{ "LINE-OUT pin", 0x5 },
5811 			{ "HP-OUT pin", 0x6 },
5812 		},
5813         },
5814 	{
5815 		.num_items = 8,
5816 		.items = {
5817 			{ "MIC1 pin", 0x0 },
5818 			{ "MIC2 pin", 0x1 },
5819 			{ "LINE1 pin", 0x2 },
5820 			{ "LINE2 pin", 0x3 },
5821 			{ "CD pin", 0x4 },
5822 			{ "Mixer", 0x5 },
5823 			{ "LINE-OUT pin", 0x6 },
5824 			{ "HP-OUT pin", 0x7 },
5825 		},
5826         },
5827 };
5828 static struct snd_kcontrol_new alc260_test_mixer[] = {
5829 	/* Output driver widgets */
5830 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5831 	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5832 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5833 	HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5834 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5835 	HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5836 
5837 	/* Modes for retasking pin widgets
5838 	 * Note: the ALC260 doesn't seem to act on requests to enable mic
5839          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5840          * mention this restriction.  At this stage it's not clear whether
5841          * this behaviour is intentional or is a hardware bug in chip
5842          * revisions available at least up until early 2006.  Therefore for
5843          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5844          * choices, but if it turns out that the lack of mic bias for these
5845          * NIDs is intentional we could change their modes from
5846          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5847 	 */
5848 	ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5849 	ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5850 	ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5851 	ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5852 	ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5853 	ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5854 
5855 	/* Loopback mixer controls */
5856 	HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5857 	HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5858 	HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5859 	HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5860 	HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5861 	HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5862 	HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5863 	HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5864 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5865 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5866 	HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5867 	HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5868 	HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5869 	HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5870 
5871 	/* Controls for GPIO pins, assuming they are configured as outputs */
5872 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5873 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5874 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5875 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5876 
5877 	/* Switches to allow the digital IO pins to be enabled.  The datasheet
5878 	 * is ambigious as to which NID is which; testing on laptops which
5879 	 * make this output available should provide clarification.
5880 	 */
5881 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5882 	ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5883 
5884 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
5885 	 * this output to turn on an external amplifier.
5886 	 */
5887 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5888 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5889 
5890 	{ } /* end */
5891 };
5892 static struct hda_verb alc260_test_init_verbs[] = {
5893 	/* Enable all GPIOs as outputs with an initial value of 0 */
5894 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5895 	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5896 	{0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5897 
5898 	/* Enable retasking pins as output, initially without power amp */
5899 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5900 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5901 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5902 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5903 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5904 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5905 
5906 	/* Disable digital (SPDIF) pins initially, but users can enable
5907 	 * them via a mixer switch.  In the case of SPDIF-out, this initverb
5908 	 * payload also sets the generation to 0, output to be in "consumer"
5909 	 * PCM format, copyright asserted, no pre-emphasis and no validity
5910 	 * control.
5911 	 */
5912 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5913 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5914 
5915 	/* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5916 	 * OUT1 sum bus when acting as an output.
5917 	 */
5918 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5919 	{0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5920 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5921 	{0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5922 
5923 	/* Start with output sum widgets muted and their output gains at min */
5924 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5925 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5926 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5927 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5928 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5929 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5930 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5931 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5932 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5933 
5934 	/* Unmute retasking pin widget output buffers since the default
5935 	 * state appears to be output.  As the pin mode is changed by the
5936 	 * user the pin mode control will take care of enabling the pin's
5937 	 * input/output buffers as needed.
5938 	 */
5939 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5940 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5941 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5942 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5943 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5944 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5945 	/* Also unmute the mono-out pin widget */
5946 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5947 
5948 	/* Mute capture amp left and right */
5949 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5950 	/* Set ADC connection select to match default mixer setting (mic1
5951 	 * pin)
5952 	 */
5953 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5954 
5955 	/* Do the same for the second ADC: mute capture input amp and
5956 	 * set ADC connection to mic1 pin
5957 	 */
5958 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5959 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5960 
5961 	/* Mute all inputs to mixer widget (even unconnected ones) */
5962 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5963 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5964 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5965 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5966 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5967 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5968 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5969 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5970 
5971 	{ }
5972 };
5973 #endif
5974 
5975 #define alc260_pcm_analog_playback	alc880_pcm_analog_alt_playback
5976 #define alc260_pcm_analog_capture	alc880_pcm_analog_capture
5977 
5978 #define alc260_pcm_digital_playback	alc880_pcm_digital_playback
5979 #define alc260_pcm_digital_capture	alc880_pcm_digital_capture
5980 
5981 /*
5982  * for BIOS auto-configuration
5983  */
5984 
5985 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5986 					const char *pfx, int *vol_bits)
5987 {
5988 	hda_nid_t nid_vol;
5989 	unsigned long vol_val, sw_val;
5990 	char name[32];
5991 	int err;
5992 
5993 	if (nid >= 0x0f && nid < 0x11) {
5994 		nid_vol = nid - 0x7;
5995 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5996 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5997 	} else if (nid == 0x11) {
5998 		nid_vol = nid - 0x7;
5999 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6000 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6001 	} else if (nid >= 0x12 && nid <= 0x15) {
6002 		nid_vol = 0x08;
6003 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6004 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6005 	} else
6006 		return 0; /* N/A */
6007 
6008 	if (!(*vol_bits & (1 << nid_vol))) {
6009 		/* first control for the volume widget */
6010 		snprintf(name, sizeof(name), "%s Playback Volume", pfx);
6011 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
6012 		if (err < 0)
6013 			return err;
6014 		*vol_bits |= (1 << nid_vol);
6015 	}
6016 	snprintf(name, sizeof(name), "%s Playback Switch", pfx);
6017 	err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
6018 	if (err < 0)
6019 		return err;
6020 	return 1;
6021 }
6022 
6023 /* add playback controls from the parsed DAC table */
6024 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6025 					     const struct auto_pin_cfg *cfg)
6026 {
6027 	hda_nid_t nid;
6028 	int err;
6029 	int vols = 0;
6030 
6031 	spec->multiout.num_dacs = 1;
6032 	spec->multiout.dac_nids = spec->private_dac_nids;
6033 	spec->multiout.dac_nids[0] = 0x02;
6034 
6035 	nid = cfg->line_out_pins[0];
6036 	if (nid) {
6037 		const char *pfx;
6038 		if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6039 			pfx = "Master";
6040 		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6041 			pfx = "Speaker";
6042 		else
6043 			pfx = "Front";
6044 		err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6045 		if (err < 0)
6046 			return err;
6047 	}
6048 
6049 	nid = cfg->speaker_pins[0];
6050 	if (nid) {
6051 		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6052 		if (err < 0)
6053 			return err;
6054 	}
6055 
6056 	nid = cfg->hp_pins[0];
6057 	if (nid) {
6058 		err = alc260_add_playback_controls(spec, nid, "Headphone",
6059 						   &vols);
6060 		if (err < 0)
6061 			return err;
6062 	}
6063 	return 0;
6064 }
6065 
6066 /* create playback/capture controls for input pins */
6067 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6068 						const struct auto_pin_cfg *cfg)
6069 {
6070 	return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6071 }
6072 
6073 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6074 					      hda_nid_t nid, int pin_type,
6075 					      int sel_idx)
6076 {
6077 	alc_set_pin_output(codec, nid, pin_type);
6078 	/* need the manual connection? */
6079 	if (nid >= 0x12) {
6080 		int idx = nid - 0x12;
6081 		snd_hda_codec_write(codec, idx + 0x0b, 0,
6082 				    AC_VERB_SET_CONNECT_SEL, sel_idx);
6083 	}
6084 }
6085 
6086 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6087 {
6088 	struct alc_spec *spec = codec->spec;
6089 	hda_nid_t nid;
6090 
6091 	nid = spec->autocfg.line_out_pins[0];
6092 	if (nid) {
6093 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
6094 		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6095 	}
6096 
6097 	nid = spec->autocfg.speaker_pins[0];
6098 	if (nid)
6099 		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6100 
6101 	nid = spec->autocfg.hp_pins[0];
6102 	if (nid)
6103 		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6104 }
6105 
6106 #define ALC260_PIN_CD_NID		0x16
6107 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6108 {
6109 	struct alc_spec *spec = codec->spec;
6110 	int i;
6111 
6112 	for (i = 0; i < AUTO_PIN_LAST; i++) {
6113 		hda_nid_t nid = spec->autocfg.input_pins[i];
6114 		if (nid >= 0x12) {
6115 			alc_set_input_pin(codec, nid, i);
6116 			if (nid != ALC260_PIN_CD_NID &&
6117 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6118 				snd_hda_codec_write(codec, nid, 0,
6119 						    AC_VERB_SET_AMP_GAIN_MUTE,
6120 						    AMP_OUT_MUTE);
6121 		}
6122 	}
6123 }
6124 
6125 /*
6126  * generic initialization of ADC, input mixers and output mixers
6127  */
6128 static struct hda_verb alc260_volume_init_verbs[] = {
6129 	/*
6130 	 * Unmute ADC0-1 and set the default input to mic-in
6131 	 */
6132 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6133 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6134 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6135 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6136 
6137 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6138 	 * mixer widget
6139 	 * Note: PASD motherboards uses the Line In 2 as the input for
6140 	 * front panel mic (mic 2)
6141 	 */
6142 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6143 	/* mute analog inputs */
6144 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6145 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6146 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6147 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6148 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6149 
6150 	/*
6151 	 * Set up output mixers (0x08 - 0x0a)
6152 	 */
6153 	/* set vol=0 to output mixers */
6154 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6155 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6156 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6157 	/* set up input amps for analog loopback */
6158 	/* Amp Indices: DAC = 0, mixer = 1 */
6159 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6160 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6161 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6162 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6163 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6164 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6165 
6166 	{ }
6167 };
6168 
6169 static int alc260_parse_auto_config(struct hda_codec *codec)
6170 {
6171 	struct alc_spec *spec = codec->spec;
6172 	int err;
6173 	static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6174 
6175 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6176 					   alc260_ignore);
6177 	if (err < 0)
6178 		return err;
6179 	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6180 	if (err < 0)
6181 		return err;
6182 	if (!spec->kctls.list)
6183 		return 0; /* can't find valid BIOS pin config */
6184 	err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6185 	if (err < 0)
6186 		return err;
6187 
6188 	spec->multiout.max_channels = 2;
6189 
6190 	if (spec->autocfg.dig_outs)
6191 		spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6192 	if (spec->kctls.list)
6193 		add_mixer(spec, spec->kctls.list);
6194 
6195 	add_verb(spec, alc260_volume_init_verbs);
6196 
6197 	spec->num_mux_defs = 1;
6198 	spec->input_mux = &spec->private_imux[0];
6199 
6200 	alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6201 
6202 	return 1;
6203 }
6204 
6205 /* additional initialization for auto-configuration model */
6206 static void alc260_auto_init(struct hda_codec *codec)
6207 {
6208 	struct alc_spec *spec = codec->spec;
6209 	alc260_auto_init_multi_out(codec);
6210 	alc260_auto_init_analog_input(codec);
6211 	if (spec->unsol_event)
6212 		alc_inithook(codec);
6213 }
6214 
6215 #ifdef CONFIG_SND_HDA_POWER_SAVE
6216 static struct hda_amp_list alc260_loopbacks[] = {
6217 	{ 0x07, HDA_INPUT, 0 },
6218 	{ 0x07, HDA_INPUT, 1 },
6219 	{ 0x07, HDA_INPUT, 2 },
6220 	{ 0x07, HDA_INPUT, 3 },
6221 	{ 0x07, HDA_INPUT, 4 },
6222 	{ } /* end */
6223 };
6224 #endif
6225 
6226 /*
6227  * ALC260 configurations
6228  */
6229 static const char *alc260_models[ALC260_MODEL_LAST] = {
6230 	[ALC260_BASIC]		= "basic",
6231 	[ALC260_HP]		= "hp",
6232 	[ALC260_HP_3013]	= "hp-3013",
6233 	[ALC260_HP_DC7600]	= "hp-dc7600",
6234 	[ALC260_FUJITSU_S702X]	= "fujitsu",
6235 	[ALC260_ACER]		= "acer",
6236 	[ALC260_WILL]		= "will",
6237 	[ALC260_REPLACER_672V]	= "replacer",
6238 	[ALC260_FAVORIT100]	= "favorit100",
6239 #ifdef CONFIG_SND_DEBUG
6240 	[ALC260_TEST]		= "test",
6241 #endif
6242 	[ALC260_AUTO]		= "auto",
6243 };
6244 
6245 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6246 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6247 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6248 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6249 	SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6250 	SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
6251 	SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6252 	SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6253 	SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6254 	SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6255 	SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6256 	SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6257 	SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6258 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6259 	SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6260 	SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6261 	SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6262 	SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6263 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6264 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6265 	{}
6266 };
6267 
6268 static struct alc_config_preset alc260_presets[] = {
6269 	[ALC260_BASIC] = {
6270 		.mixers = { alc260_base_output_mixer,
6271 			    alc260_input_mixer },
6272 		.init_verbs = { alc260_init_verbs },
6273 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6274 		.dac_nids = alc260_dac_nids,
6275 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6276 		.adc_nids = alc260_adc_nids,
6277 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6278 		.channel_mode = alc260_modes,
6279 		.input_mux = &alc260_capture_source,
6280 	},
6281 	[ALC260_HP] = {
6282 		.mixers = { alc260_hp_output_mixer,
6283 			    alc260_input_mixer },
6284 		.init_verbs = { alc260_init_verbs,
6285 				alc260_hp_unsol_verbs },
6286 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6287 		.dac_nids = alc260_dac_nids,
6288 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6289 		.adc_nids = alc260_adc_nids_alt,
6290 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6291 		.channel_mode = alc260_modes,
6292 		.input_mux = &alc260_capture_source,
6293 		.unsol_event = alc260_hp_unsol_event,
6294 		.init_hook = alc260_hp_automute,
6295 	},
6296 	[ALC260_HP_DC7600] = {
6297 		.mixers = { alc260_hp_dc7600_mixer,
6298 			    alc260_input_mixer },
6299 		.init_verbs = { alc260_init_verbs,
6300 				alc260_hp_dc7600_verbs },
6301 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6302 		.dac_nids = alc260_dac_nids,
6303 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6304 		.adc_nids = alc260_adc_nids_alt,
6305 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6306 		.channel_mode = alc260_modes,
6307 		.input_mux = &alc260_capture_source,
6308 		.unsol_event = alc260_hp_3012_unsol_event,
6309 		.init_hook = alc260_hp_3012_automute,
6310 	},
6311 	[ALC260_HP_3013] = {
6312 		.mixers = { alc260_hp_3013_mixer,
6313 			    alc260_input_mixer },
6314 		.init_verbs = { alc260_hp_3013_init_verbs,
6315 				alc260_hp_3013_unsol_verbs },
6316 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6317 		.dac_nids = alc260_dac_nids,
6318 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6319 		.adc_nids = alc260_adc_nids_alt,
6320 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6321 		.channel_mode = alc260_modes,
6322 		.input_mux = &alc260_capture_source,
6323 		.unsol_event = alc260_hp_3013_unsol_event,
6324 		.init_hook = alc260_hp_3013_automute,
6325 	},
6326 	[ALC260_FUJITSU_S702X] = {
6327 		.mixers = { alc260_fujitsu_mixer },
6328 		.init_verbs = { alc260_fujitsu_init_verbs },
6329 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6330 		.dac_nids = alc260_dac_nids,
6331 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6332 		.adc_nids = alc260_dual_adc_nids,
6333 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6334 		.channel_mode = alc260_modes,
6335 		.num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6336 		.input_mux = alc260_fujitsu_capture_sources,
6337 	},
6338 	[ALC260_ACER] = {
6339 		.mixers = { alc260_acer_mixer },
6340 		.init_verbs = { alc260_acer_init_verbs },
6341 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6342 		.dac_nids = alc260_dac_nids,
6343 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6344 		.adc_nids = alc260_dual_adc_nids,
6345 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6346 		.channel_mode = alc260_modes,
6347 		.num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6348 		.input_mux = alc260_acer_capture_sources,
6349 	},
6350 	[ALC260_FAVORIT100] = {
6351 		.mixers = { alc260_favorit100_mixer },
6352 		.init_verbs = { alc260_favorit100_init_verbs },
6353 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6354 		.dac_nids = alc260_dac_nids,
6355 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6356 		.adc_nids = alc260_dual_adc_nids,
6357 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6358 		.channel_mode = alc260_modes,
6359 		.num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6360 		.input_mux = alc260_favorit100_capture_sources,
6361 	},
6362 	[ALC260_WILL] = {
6363 		.mixers = { alc260_will_mixer },
6364 		.init_verbs = { alc260_init_verbs, alc260_will_verbs },
6365 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6366 		.dac_nids = alc260_dac_nids,
6367 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6368 		.adc_nids = alc260_adc_nids,
6369 		.dig_out_nid = ALC260_DIGOUT_NID,
6370 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6371 		.channel_mode = alc260_modes,
6372 		.input_mux = &alc260_capture_source,
6373 	},
6374 	[ALC260_REPLACER_672V] = {
6375 		.mixers = { alc260_replacer_672v_mixer },
6376 		.init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6377 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6378 		.dac_nids = alc260_dac_nids,
6379 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6380 		.adc_nids = alc260_adc_nids,
6381 		.dig_out_nid = ALC260_DIGOUT_NID,
6382 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6383 		.channel_mode = alc260_modes,
6384 		.input_mux = &alc260_capture_source,
6385 		.unsol_event = alc260_replacer_672v_unsol_event,
6386 		.init_hook = alc260_replacer_672v_automute,
6387 	},
6388 #ifdef CONFIG_SND_DEBUG
6389 	[ALC260_TEST] = {
6390 		.mixers = { alc260_test_mixer },
6391 		.init_verbs = { alc260_test_init_verbs },
6392 		.num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6393 		.dac_nids = alc260_test_dac_nids,
6394 		.num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6395 		.adc_nids = alc260_test_adc_nids,
6396 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6397 		.channel_mode = alc260_modes,
6398 		.num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6399 		.input_mux = alc260_test_capture_sources,
6400 	},
6401 #endif
6402 };
6403 
6404 static int patch_alc260(struct hda_codec *codec)
6405 {
6406 	struct alc_spec *spec;
6407 	int err, board_config;
6408 
6409 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6410 	if (spec == NULL)
6411 		return -ENOMEM;
6412 
6413 	codec->spec = spec;
6414 
6415 	board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6416 						  alc260_models,
6417 						  alc260_cfg_tbl);
6418 	if (board_config < 0) {
6419 		snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6420 			   codec->chip_name);
6421 		board_config = ALC260_AUTO;
6422 	}
6423 
6424 	if (board_config == ALC260_AUTO) {
6425 		/* automatic parse from the BIOS config */
6426 		err = alc260_parse_auto_config(codec);
6427 		if (err < 0) {
6428 			alc_free(codec);
6429 			return err;
6430 		} else if (!err) {
6431 			printk(KERN_INFO
6432 			       "hda_codec: Cannot set up configuration "
6433 			       "from BIOS.  Using base mode...\n");
6434 			board_config = ALC260_BASIC;
6435 		}
6436 	}
6437 
6438 	err = snd_hda_attach_beep_device(codec, 0x1);
6439 	if (err < 0) {
6440 		alc_free(codec);
6441 		return err;
6442 	}
6443 
6444 	if (board_config != ALC260_AUTO)
6445 		setup_preset(codec, &alc260_presets[board_config]);
6446 
6447 	spec->stream_analog_playback = &alc260_pcm_analog_playback;
6448 	spec->stream_analog_capture = &alc260_pcm_analog_capture;
6449 
6450 	spec->stream_digital_playback = &alc260_pcm_digital_playback;
6451 	spec->stream_digital_capture = &alc260_pcm_digital_capture;
6452 
6453 	if (!spec->adc_nids && spec->input_mux) {
6454 		/* check whether NID 0x04 is valid */
6455 		unsigned int wcap = get_wcaps(codec, 0x04);
6456 		wcap = get_wcaps_type(wcap);
6457 		/* get type */
6458 		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6459 			spec->adc_nids = alc260_adc_nids_alt;
6460 			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6461 		} else {
6462 			spec->adc_nids = alc260_adc_nids;
6463 			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6464 		}
6465 	}
6466 	set_capture_mixer(codec);
6467 	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6468 
6469 	spec->vmaster_nid = 0x08;
6470 
6471 	codec->patch_ops = alc_patch_ops;
6472 	if (board_config == ALC260_AUTO)
6473 		spec->init_hook = alc260_auto_init;
6474 #ifdef CONFIG_SND_HDA_POWER_SAVE
6475 	if (!spec->loopback.amplist)
6476 		spec->loopback.amplist = alc260_loopbacks;
6477 #endif
6478 	codec->proc_widget_hook = print_realtek_coef;
6479 
6480 	return 0;
6481 }
6482 
6483 
6484 /*
6485  * ALC882/883/885/888/889 support
6486  *
6487  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6488  * configuration.  Each pin widget can choose any input DACs and a mixer.
6489  * Each ADC is connected from a mixer of all inputs.  This makes possible
6490  * 6-channel independent captures.
6491  *
6492  * In addition, an independent DAC for the multi-playback (not used in this
6493  * driver yet).
6494  */
6495 #define ALC882_DIGOUT_NID	0x06
6496 #define ALC882_DIGIN_NID	0x0a
6497 #define ALC883_DIGOUT_NID	ALC882_DIGOUT_NID
6498 #define ALC883_DIGIN_NID	ALC882_DIGIN_NID
6499 #define ALC1200_DIGOUT_NID	0x10
6500 
6501 
6502 static struct hda_channel_mode alc882_ch_modes[1] = {
6503 	{ 8, NULL }
6504 };
6505 
6506 /* DACs */
6507 static hda_nid_t alc882_dac_nids[4] = {
6508 	/* front, rear, clfe, rear_surr */
6509 	0x02, 0x03, 0x04, 0x05
6510 };
6511 #define alc883_dac_nids		alc882_dac_nids
6512 
6513 /* ADCs */
6514 #define alc882_adc_nids		alc880_adc_nids
6515 #define alc882_adc_nids_alt	alc880_adc_nids_alt
6516 #define alc883_adc_nids		alc882_adc_nids_alt
6517 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6518 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6519 #define alc889_adc_nids		alc880_adc_nids
6520 
6521 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6522 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6523 #define alc883_capsrc_nids	alc882_capsrc_nids_alt
6524 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6525 #define alc889_capsrc_nids	alc882_capsrc_nids
6526 
6527 /* input MUX */
6528 /* FIXME: should be a matrix-type input source selection */
6529 
6530 static struct hda_input_mux alc882_capture_source = {
6531 	.num_items = 4,
6532 	.items = {
6533 		{ "Mic", 0x0 },
6534 		{ "Front Mic", 0x1 },
6535 		{ "Line", 0x2 },
6536 		{ "CD", 0x4 },
6537 	},
6538 };
6539 
6540 #define alc883_capture_source	alc882_capture_source
6541 
6542 static struct hda_input_mux alc889_capture_source = {
6543 	.num_items = 3,
6544 	.items = {
6545 		{ "Front Mic", 0x0 },
6546 		{ "Mic", 0x3 },
6547 		{ "Line", 0x2 },
6548 	},
6549 };
6550 
6551 static struct hda_input_mux mb5_capture_source = {
6552 	.num_items = 3,
6553 	.items = {
6554 		{ "Mic", 0x1 },
6555 		{ "Line", 0x2 },
6556 		{ "CD", 0x4 },
6557 	},
6558 };
6559 
6560 static struct hda_input_mux alc883_3stack_6ch_intel = {
6561 	.num_items = 4,
6562 	.items = {
6563 		{ "Mic", 0x1 },
6564 		{ "Front Mic", 0x0 },
6565 		{ "Line", 0x2 },
6566 		{ "CD", 0x4 },
6567 	},
6568 };
6569 
6570 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6571 	.num_items = 2,
6572 	.items = {
6573 		{ "Mic", 0x1 },
6574 		{ "Line", 0x2 },
6575 	},
6576 };
6577 
6578 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6579 	.num_items = 4,
6580 	.items = {
6581 		{ "Mic", 0x0 },
6582 		{ "iMic", 0x1 },
6583 		{ "Line", 0x2 },
6584 		{ "CD", 0x4 },
6585 	},
6586 };
6587 
6588 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6589 	.num_items = 2,
6590 	.items = {
6591 		{ "Mic", 0x0 },
6592 		{ "Int Mic", 0x1 },
6593 	},
6594 };
6595 
6596 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6597 	.num_items = 3,
6598 	.items = {
6599 		{ "Mic", 0x0 },
6600 		{ "Front Mic", 0x1 },
6601 		{ "Line", 0x4 },
6602 	},
6603 };
6604 
6605 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6606 	.num_items = 2,
6607 	.items = {
6608 		{ "Mic", 0x0 },
6609 		{ "Line", 0x2 },
6610 	},
6611 };
6612 
6613 static struct hda_input_mux alc889A_mb31_capture_source = {
6614 	.num_items = 2,
6615 	.items = {
6616 		{ "Mic", 0x0 },
6617 		/* Front Mic (0x01) unused */
6618 		{ "Line", 0x2 },
6619 		/* Line 2 (0x03) unused */
6620 		/* CD (0x04) unsused? */
6621 	},
6622 };
6623 
6624 /*
6625  * 2ch mode
6626  */
6627 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6628 	{ 2, NULL }
6629 };
6630 
6631 /*
6632  * 2ch mode
6633  */
6634 static struct hda_verb alc882_3ST_ch2_init[] = {
6635 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6636 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6637 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6638 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6639 	{ } /* end */
6640 };
6641 
6642 /*
6643  * 4ch mode
6644  */
6645 static struct hda_verb alc882_3ST_ch4_init[] = {
6646 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6647 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6648 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6649 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6650 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6651 	{ } /* end */
6652 };
6653 
6654 /*
6655  * 6ch mode
6656  */
6657 static struct hda_verb alc882_3ST_ch6_init[] = {
6658 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6659 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6660 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6661 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6662 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6663 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6664 	{ } /* end */
6665 };
6666 
6667 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6668 	{ 2, alc882_3ST_ch2_init },
6669 	{ 4, alc882_3ST_ch4_init },
6670 	{ 6, alc882_3ST_ch6_init },
6671 };
6672 
6673 #define alc883_3ST_6ch_modes	alc882_3ST_6ch_modes
6674 
6675 /*
6676  * 2ch mode
6677  */
6678 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6679 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6680 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6681 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6682 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6683 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6684 	{ } /* end */
6685 };
6686 
6687 /*
6688  * 4ch mode
6689  */
6690 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6691 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6692 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6693 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6694 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6695 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6696 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6697 	{ } /* end */
6698 };
6699 
6700 /*
6701  * 6ch mode
6702  */
6703 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6704 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6705 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6706 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6707 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6708 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6709 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6710 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6711 	{ } /* end */
6712 };
6713 
6714 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6715 	{ 2, alc883_3ST_ch2_clevo_init },
6716 	{ 4, alc883_3ST_ch4_clevo_init },
6717 	{ 6, alc883_3ST_ch6_clevo_init },
6718 };
6719 
6720 
6721 /*
6722  * 6ch mode
6723  */
6724 static struct hda_verb alc882_sixstack_ch6_init[] = {
6725 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6726 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6727 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6728 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6729 	{ } /* end */
6730 };
6731 
6732 /*
6733  * 8ch mode
6734  */
6735 static struct hda_verb alc882_sixstack_ch8_init[] = {
6736 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6737 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6738 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6739 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6740 	{ } /* end */
6741 };
6742 
6743 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6744 	{ 6, alc882_sixstack_ch6_init },
6745 	{ 8, alc882_sixstack_ch8_init },
6746 };
6747 
6748 /*
6749  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6750  */
6751 
6752 /*
6753  * 2ch mode
6754  */
6755 static struct hda_verb alc885_mbp_ch2_init[] = {
6756 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6757 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6758 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6759 	{ } /* end */
6760 };
6761 
6762 /*
6763  * 4ch mode
6764  */
6765 static struct hda_verb alc885_mbp_ch4_init[] = {
6766 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6767 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6768 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6769 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6770 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6771 	{ } /* end */
6772 };
6773 
6774 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
6775 	{ 2, alc885_mbp_ch2_init },
6776 	{ 4, alc885_mbp_ch4_init },
6777 };
6778 
6779 /*
6780  * 2ch
6781  * Speakers/Woofer/HP = Front
6782  * LineIn = Input
6783  */
6784 static struct hda_verb alc885_mb5_ch2_init[] = {
6785 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6786 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6787 	{ } /* end */
6788 };
6789 
6790 /*
6791  * 6ch mode
6792  * Speakers/HP = Front
6793  * Woofer = LFE
6794  * LineIn = Surround
6795  */
6796 static struct hda_verb alc885_mb5_ch6_init[] = {
6797 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6798 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6799 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6800 	{ } /* end */
6801 };
6802 
6803 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6804 	{ 2, alc885_mb5_ch2_init },
6805 	{ 6, alc885_mb5_ch6_init },
6806 };
6807 
6808 
6809 /*
6810  * 2ch mode
6811  */
6812 static struct hda_verb alc883_4ST_ch2_init[] = {
6813 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6814 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6815 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6816 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6817 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6818 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6819 	{ } /* end */
6820 };
6821 
6822 /*
6823  * 4ch mode
6824  */
6825 static struct hda_verb alc883_4ST_ch4_init[] = {
6826 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6827 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6828 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6829 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6830 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6831 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6832 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6833 	{ } /* end */
6834 };
6835 
6836 /*
6837  * 6ch mode
6838  */
6839 static struct hda_verb alc883_4ST_ch6_init[] = {
6840 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6841 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6842 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6843 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6844 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6845 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6846 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6847 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6848 	{ } /* end */
6849 };
6850 
6851 /*
6852  * 8ch mode
6853  */
6854 static struct hda_verb alc883_4ST_ch8_init[] = {
6855 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6856 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6857 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6858 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6859 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6860 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6861 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6862 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6863 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6864 	{ } /* end */
6865 };
6866 
6867 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6868 	{ 2, alc883_4ST_ch2_init },
6869 	{ 4, alc883_4ST_ch4_init },
6870 	{ 6, alc883_4ST_ch6_init },
6871 	{ 8, alc883_4ST_ch8_init },
6872 };
6873 
6874 
6875 /*
6876  * 2ch mode
6877  */
6878 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6879 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6880 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6881 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6882 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6883 	{ } /* end */
6884 };
6885 
6886 /*
6887  * 4ch mode
6888  */
6889 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6890 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6891 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6892 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6893 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6894 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6895 	{ } /* end */
6896 };
6897 
6898 /*
6899  * 6ch mode
6900  */
6901 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6902 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6903 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6904 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6905 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6906 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6907 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6908 	{ } /* end */
6909 };
6910 
6911 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6912 	{ 2, alc883_3ST_ch2_intel_init },
6913 	{ 4, alc883_3ST_ch4_intel_init },
6914 	{ 6, alc883_3ST_ch6_intel_init },
6915 };
6916 
6917 /*
6918  * 2ch mode
6919  */
6920 static struct hda_verb alc889_ch2_intel_init[] = {
6921 	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6922 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
6923 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
6924 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
6925 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6926 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6927 	{ } /* end */
6928 };
6929 
6930 /*
6931  * 6ch mode
6932  */
6933 static struct hda_verb alc889_ch6_intel_init[] = {
6934 	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6935 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6936 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6937 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6938 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6939 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6940 	{ } /* end */
6941 };
6942 
6943 /*
6944  * 8ch mode
6945  */
6946 static struct hda_verb alc889_ch8_intel_init[] = {
6947 	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6948 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6949 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6950 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6951 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
6952 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6953 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6954 	{ } /* end */
6955 };
6956 
6957 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
6958 	{ 2, alc889_ch2_intel_init },
6959 	{ 6, alc889_ch6_intel_init },
6960 	{ 8, alc889_ch8_intel_init },
6961 };
6962 
6963 /*
6964  * 6ch mode
6965  */
6966 static struct hda_verb alc883_sixstack_ch6_init[] = {
6967 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6968 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6969 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6970 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6971 	{ } /* end */
6972 };
6973 
6974 /*
6975  * 8ch mode
6976  */
6977 static struct hda_verb alc883_sixstack_ch8_init[] = {
6978 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6979 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6980 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6981 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6982 	{ } /* end */
6983 };
6984 
6985 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6986 	{ 6, alc883_sixstack_ch6_init },
6987 	{ 8, alc883_sixstack_ch8_init },
6988 };
6989 
6990 
6991 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6992  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6993  */
6994 static struct snd_kcontrol_new alc882_base_mixer[] = {
6995 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6996 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6997 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6998 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6999 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7000 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7001 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7002 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7003 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7004 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7005 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7006 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7007 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7008 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7009 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7010 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7011 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7012 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7013 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7014 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7015 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7016 	{ } /* end */
7017 };
7018 
7019 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7020 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7021 	HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7022 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7023 	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7024 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7025 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7026 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7027 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7028 	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7029 	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7030 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7031 	{ } /* end */
7032 };
7033 
7034 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7035 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7036 	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7037 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7038 	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7039 	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7040 	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7041 	HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7042 	HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
7043 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7044 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7045 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7046 	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7047 	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7048 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7049 	{ } /* end */
7050 };
7051 
7052 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7053 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7054 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7055 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7056 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7057 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7058 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7059 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7060 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7061 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7062 	{ } /* end */
7063 };
7064 
7065 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7066 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7067 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7068 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7069 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7070 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7071 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7072 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7073 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7074 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7075 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7076 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7077 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7078 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7079 	{ } /* end */
7080 };
7081 
7082 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7083  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7084  */
7085 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7086 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7087 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7088 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7089 	HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7090 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7091 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7092 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7093 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7094 	HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7095 	HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7096 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7097 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7098 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7099 	{ } /* end */
7100 };
7101 
7102 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7103 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7104 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7105 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7106 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7107 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7108 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7109 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7110 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7111 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7112 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7113 	{ } /* end */
7114 };
7115 
7116 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7117 	{
7118 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7119 		.name = "Channel Mode",
7120 		.info = alc_ch_mode_info,
7121 		.get = alc_ch_mode_get,
7122 		.put = alc_ch_mode_put,
7123 	},
7124 	{ } /* end */
7125 };
7126 
7127 static struct hda_verb alc882_base_init_verbs[] = {
7128 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7129 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7130 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7131 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7132 	/* Rear mixer */
7133 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7134 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7135 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7136 	/* CLFE mixer */
7137 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7138 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7139 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7140 	/* Side mixer */
7141 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7142 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7143 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7144 
7145 	/* mute analog input loopbacks */
7146 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7147 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7148 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7149 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7150 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7151 
7152 	/* Front Pin: output 0 (0x0c) */
7153 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7154 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7155 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7156 	/* Rear Pin: output 1 (0x0d) */
7157 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7158 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7159 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7160 	/* CLFE Pin: output 2 (0x0e) */
7161 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7162 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7163 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7164 	/* Side Pin: output 3 (0x0f) */
7165 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7166 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7167 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7168 	/* Mic (rear) pin: input vref at 80% */
7169 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7170 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7171 	/* Front Mic pin: input vref at 80% */
7172 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7173 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7174 	/* Line In pin: input */
7175 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7176 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7177 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
7178 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7179 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7180 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7181 	/* CD pin widget for input */
7182 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7183 
7184 	/* FIXME: use matrix-type input source selection */
7185 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7186 	/* Input mixer2 */
7187 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7188 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7189 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7190 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7191 	/* Input mixer3 */
7192 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7193 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7194 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7195 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7196 	/* ADC2: mute amp left and right */
7197 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7198 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7199 	/* ADC3: mute amp left and right */
7200 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7201 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7202 
7203 	{ }
7204 };
7205 
7206 static struct hda_verb alc882_adc1_init_verbs[] = {
7207 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7208 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7209 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7210 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7211 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7212 	/* ADC1: mute amp left and right */
7213 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7214 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7215 	{ }
7216 };
7217 
7218 static struct hda_verb alc882_eapd_verbs[] = {
7219 	/* change to EAPD mode */
7220 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7221 	{0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7222 	{ }
7223 };
7224 
7225 static struct hda_verb alc889_eapd_verbs[] = {
7226 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7227 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7228 	{ }
7229 };
7230 
7231 static struct hda_verb alc_hp15_unsol_verbs[] = {
7232 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7233 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7234 	{}
7235 };
7236 
7237 static struct hda_verb alc885_init_verbs[] = {
7238 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7239 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7240 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7241 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7242 	/* Rear mixer */
7243 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7244 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7245 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7246 	/* CLFE mixer */
7247 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7248 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7249 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7250 	/* Side mixer */
7251 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7252 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7253 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7254 
7255 	/* mute analog input loopbacks */
7256 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7257 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7258 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7259 
7260 	/* Front HP Pin: output 0 (0x0c) */
7261 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7262 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7263 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7264 	/* Front Pin: output 0 (0x0c) */
7265 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7266 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7267 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7268 	/* Rear Pin: output 1 (0x0d) */
7269 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7270 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7271 	{0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7272 	/* CLFE Pin: output 2 (0x0e) */
7273 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7274 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7275 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7276 	/* Side Pin: output 3 (0x0f) */
7277 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7278 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7279 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7280 	/* Mic (rear) pin: input vref at 80% */
7281 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7282 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7283 	/* Front Mic pin: input vref at 80% */
7284 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7285 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7286 	/* Line In pin: input */
7287 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7288 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7289 
7290 	/* Mixer elements: 0x18, , 0x1a, 0x1b */
7291 	/* Input mixer1 */
7292 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7293 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7294 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7295 	/* Input mixer2 */
7296 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7297 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7298 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7299 	/* Input mixer3 */
7300 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7301 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7302 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7303 	/* ADC2: mute amp left and right */
7304 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7305 	/* ADC3: mute amp left and right */
7306 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7307 
7308 	{ }
7309 };
7310 
7311 static struct hda_verb alc885_init_input_verbs[] = {
7312 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7313 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7314 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7315 	{ }
7316 };
7317 
7318 
7319 /* Unmute Selector 24h and set the default input to front mic */
7320 static struct hda_verb alc889_init_input_verbs[] = {
7321 	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7322 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7323 	{ }
7324 };
7325 
7326 
7327 #define alc883_init_verbs	alc882_base_init_verbs
7328 
7329 /* Mac Pro test */
7330 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7331 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7332 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7333 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7334 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7335 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7336 	/* FIXME: this looks suspicious...
7337 	HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
7338 	HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
7339 	*/
7340 	{ } /* end */
7341 };
7342 
7343 static struct hda_verb alc882_macpro_init_verbs[] = {
7344 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7345 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7346 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7347 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7348 	/* Front Pin: output 0 (0x0c) */
7349 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7350 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7351 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7352 	/* Front Mic pin: input vref at 80% */
7353 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7354 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7355 	/* Speaker:  output */
7356 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7357 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7358 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7359 	/* Headphone output (output 0 - 0x0c) */
7360 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7361 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7362 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7363 
7364 	/* FIXME: use matrix-type input source selection */
7365 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7366 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7367 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7368 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7369 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7370 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7371 	/* Input mixer2 */
7372 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7373 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7374 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7375 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7376 	/* Input mixer3 */
7377 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7378 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7379 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7380 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7381 	/* ADC1: mute amp left and right */
7382 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7383 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7384 	/* ADC2: mute amp left and right */
7385 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7386 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7387 	/* ADC3: mute amp left and right */
7388 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7389 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7390 
7391 	{ }
7392 };
7393 
7394 /* Macbook 5,1 */
7395 static struct hda_verb alc885_mb5_init_verbs[] = {
7396 	/* DACs */
7397 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7398 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7399 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7400 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7401 	/* Front mixer */
7402 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7403 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7404 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7405 	/* Surround mixer */
7406 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7407 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7408 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7409 	/* LFE mixer */
7410 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7411 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7412 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7413 	/* HP mixer */
7414 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7415 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7416 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7417 	/* Front Pin (0x0c) */
7418 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7419 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7420 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7421 	/* LFE Pin (0x0e) */
7422 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7423 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7424 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7425 	/* HP Pin (0x0f) */
7426 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7427 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7428 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7429 	/* Front Mic pin: input vref at 80% */
7430 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7431 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7432 	/* Line In pin */
7433 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7434 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7435 
7436 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7437 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7438 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7439 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7440 	{ }
7441 };
7442 
7443 /* Macbook Pro rev3 */
7444 static struct hda_verb alc885_mbp3_init_verbs[] = {
7445 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7446 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7447 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7448 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7449 	/* Rear mixer */
7450 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7451 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7452 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7453 	/* HP mixer */
7454 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7455 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7456 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7457 	/* Front Pin: output 0 (0x0c) */
7458 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7459 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7460 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7461 	/* HP Pin: output 0 (0x0e) */
7462 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7463 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7464 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7465 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7466 	/* Mic (rear) pin: input vref at 80% */
7467 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7468 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7469 	/* Front Mic pin: input vref at 80% */
7470 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7471 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7472 	/* Line In pin: use output 1 when in LineOut mode */
7473 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7474 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7475 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7476 
7477 	/* FIXME: use matrix-type input source selection */
7478 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7479 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7480 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7481 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7482 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7483 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7484 	/* Input mixer2 */
7485 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7486 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7487 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7488 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7489 	/* Input mixer3 */
7490 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7491 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7492 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7493 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7494 	/* ADC1: mute amp left and right */
7495 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7496 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7497 	/* ADC2: mute amp left and right */
7498 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7499 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7500 	/* ADC3: mute amp left and right */
7501 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7502 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7503 
7504 	{ }
7505 };
7506 
7507 /* iMac 24 mixer. */
7508 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7509 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7510 	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7511 	{ } /* end */
7512 };
7513 
7514 /* iMac 24 init verbs. */
7515 static struct hda_verb alc885_imac24_init_verbs[] = {
7516 	/* Internal speakers: output 0 (0x0c) */
7517 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7518 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7519 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7520 	/* Internal speakers: output 0 (0x0c) */
7521 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7522 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7523 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7524 	/* Headphone: output 0 (0x0c) */
7525 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7526 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7527 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7528 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7529 	/* Front Mic: input vref at 80% */
7530 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7531 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7532 	{ }
7533 };
7534 
7535 /* Toggle speaker-output according to the hp-jack state */
7536 static void alc885_imac24_setup(struct hda_codec *codec)
7537 {
7538 	struct alc_spec *spec = codec->spec;
7539 
7540 	spec->autocfg.hp_pins[0] = 0x14;
7541 	spec->autocfg.speaker_pins[0] = 0x18;
7542 	spec->autocfg.speaker_pins[1] = 0x1a;
7543 }
7544 
7545 static void alc885_mbp3_setup(struct hda_codec *codec)
7546 {
7547 	struct alc_spec *spec = codec->spec;
7548 
7549 	spec->autocfg.hp_pins[0] = 0x15;
7550 	spec->autocfg.speaker_pins[0] = 0x14;
7551 }
7552 
7553 
7554 static struct hda_verb alc882_targa_verbs[] = {
7555 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7556 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7557 
7558 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7559 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7560 
7561 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7562 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7563 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7564 
7565 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7566 	{ } /* end */
7567 };
7568 
7569 /* toggle speaker-output according to the hp-jack state */
7570 static void alc882_targa_automute(struct hda_codec *codec)
7571 {
7572 	struct alc_spec *spec = codec->spec;
7573 	alc_automute_amp(codec);
7574 	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7575 				  spec->jack_present ? 1 : 3);
7576 }
7577 
7578 static void alc882_targa_setup(struct hda_codec *codec)
7579 {
7580 	struct alc_spec *spec = codec->spec;
7581 
7582 	spec->autocfg.hp_pins[0] = 0x14;
7583 	spec->autocfg.speaker_pins[0] = 0x1b;
7584 }
7585 
7586 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7587 {
7588 	if ((res >> 26) == ALC880_HP_EVENT)
7589 		alc882_targa_automute(codec);
7590 }
7591 
7592 static struct hda_verb alc882_asus_a7j_verbs[] = {
7593 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7594 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7595 
7596 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7597 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7598 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7599 
7600 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7601 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7602 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7603 
7604 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7605 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7606 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7607 	{ } /* end */
7608 };
7609 
7610 static struct hda_verb alc882_asus_a7m_verbs[] = {
7611 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7612 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7613 
7614 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7615 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7616 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7617 
7618 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7619 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7620 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7621 
7622 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7623 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7624 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7625  	{ } /* end */
7626 };
7627 
7628 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7629 {
7630 	unsigned int gpiostate, gpiomask, gpiodir;
7631 
7632 	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7633 				       AC_VERB_GET_GPIO_DATA, 0);
7634 
7635 	if (!muted)
7636 		gpiostate |= (1 << pin);
7637 	else
7638 		gpiostate &= ~(1 << pin);
7639 
7640 	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7641 				      AC_VERB_GET_GPIO_MASK, 0);
7642 	gpiomask |= (1 << pin);
7643 
7644 	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7645 				     AC_VERB_GET_GPIO_DIRECTION, 0);
7646 	gpiodir |= (1 << pin);
7647 
7648 
7649 	snd_hda_codec_write(codec, codec->afg, 0,
7650 			    AC_VERB_SET_GPIO_MASK, gpiomask);
7651 	snd_hda_codec_write(codec, codec->afg, 0,
7652 			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7653 
7654 	msleep(1);
7655 
7656 	snd_hda_codec_write(codec, codec->afg, 0,
7657 			    AC_VERB_SET_GPIO_DATA, gpiostate);
7658 }
7659 
7660 /* set up GPIO at initialization */
7661 static void alc885_macpro_init_hook(struct hda_codec *codec)
7662 {
7663 	alc882_gpio_mute(codec, 0, 0);
7664 	alc882_gpio_mute(codec, 1, 0);
7665 }
7666 
7667 /* set up GPIO and update auto-muting at initialization */
7668 static void alc885_imac24_init_hook(struct hda_codec *codec)
7669 {
7670 	alc885_macpro_init_hook(codec);
7671 	alc_automute_amp(codec);
7672 }
7673 
7674 /*
7675  * generic initialization of ADC, input mixers and output mixers
7676  */
7677 static struct hda_verb alc883_auto_init_verbs[] = {
7678 	/*
7679 	 * Unmute ADC0-2 and set the default input to mic-in
7680 	 */
7681 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7682 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7683 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7684 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7685 
7686 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7687 	 * mixer widget
7688 	 * Note: PASD motherboards uses the Line In 2 as the input for
7689 	 * front panel mic (mic 2)
7690 	 */
7691 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7692 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7693 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7694 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7695 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7696 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7697 
7698 	/*
7699 	 * Set up output mixers (0x0c - 0x0f)
7700 	 */
7701 	/* set vol=0 to output mixers */
7702 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7703 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7704 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7705 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7706 	/* set up input amps for analog loopback */
7707 	/* Amp Indices: DAC = 0, mixer = 1 */
7708 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7709 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7710 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7711 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7712 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7713 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7714 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7715 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7716 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7717 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7718 
7719 	/* FIXME: use matrix-type input source selection */
7720 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7721 	/* Input mixer2 */
7722 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7723 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7724 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7725 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7726 	/* Input mixer3 */
7727 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7728 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7729 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7730 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7731 
7732 	{ }
7733 };
7734 
7735 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7736 static struct hda_verb alc889A_mb31_ch2_init[] = {
7737 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7738 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7739 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7740 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7741 	{ } /* end */
7742 };
7743 
7744 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7745 static struct hda_verb alc889A_mb31_ch4_init[] = {
7746 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7747 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7748 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7749 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7750 	{ } /* end */
7751 };
7752 
7753 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7754 static struct hda_verb alc889A_mb31_ch5_init[] = {
7755 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7756 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7757 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7758 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7759 	{ } /* end */
7760 };
7761 
7762 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7763 static struct hda_verb alc889A_mb31_ch6_init[] = {
7764 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7765 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7766 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7767 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7768 	{ } /* end */
7769 };
7770 
7771 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7772 	{ 2, alc889A_mb31_ch2_init },
7773 	{ 4, alc889A_mb31_ch4_init },
7774 	{ 5, alc889A_mb31_ch5_init },
7775 	{ 6, alc889A_mb31_ch6_init },
7776 };
7777 
7778 static struct hda_verb alc883_medion_eapd_verbs[] = {
7779         /* eanable EAPD on medion laptop */
7780 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7781 	{0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7782 	{ }
7783 };
7784 
7785 #define alc883_base_mixer	alc882_base_mixer
7786 
7787 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7788 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7789 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7790 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7791 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7792 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7793 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7794 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7795 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7796 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7797 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7798 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7799 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7800 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7801 	{ } /* end */
7802 };
7803 
7804 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7805 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7806 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7807 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7808 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7809 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7810 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7811 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7812 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7813 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7814 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7815 	{ } /* end */
7816 };
7817 
7818 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7819 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7820 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7821 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7822 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7823 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7824 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7825 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7826 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7827 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7828 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7829 	{ } /* end */
7830 };
7831 
7832 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7833 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7834 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7835 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7836 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7837 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7838 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7839 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7840 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7841 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7842 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7843 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7844 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7845 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7846 	{ } /* end */
7847 };
7848 
7849 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7850 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7851 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7852 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7853 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7854 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7855 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7856 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7857 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7858 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7859 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7860 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7861 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7862 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7863 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7864 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7865 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7866 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7867 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7868 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7869 	{ } /* end */
7870 };
7871 
7872 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7873 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7874 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7875 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7876 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7877 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7878 			      HDA_OUTPUT),
7879 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7880 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7881 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7882 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7883 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7884 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7885 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7886 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7887 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7888 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7889 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7890 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7891 	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7892 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7893 	{ } /* end */
7894 };
7895 
7896 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
7897 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7898 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7899 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7900 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7901 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7902 			      HDA_OUTPUT),
7903 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7904 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7905 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7906 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7907 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
7908 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7909 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7910 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7911 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
7912 	HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
7913 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
7914 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7915 	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7916 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7917 	{ } /* end */
7918 };
7919 
7920 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7921 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7922 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7923 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7924 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7925 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7926 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7927 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7928 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7929 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7930 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7931 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7932 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7933 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7934 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7935 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7936 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7937 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7938 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7939 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7940 	{ } /* end */
7941 };
7942 
7943 static struct snd_kcontrol_new alc883_targa_mixer[] = {
7944 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7945 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7946 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7947 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7948 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7949 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7950 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7951 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7952 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7953 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7954 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7955 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7956 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7957 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7958 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7959 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7960 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7961 	{ } /* end */
7962 };
7963 
7964 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
7965 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7966 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7967 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7968 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7969 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7970 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7971 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7972 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7973 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7974 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7975 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7976 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7977 	{ } /* end */
7978 };
7979 
7980 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
7981 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7982 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7983 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7984 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7985 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7986 	{ } /* end */
7987 };
7988 
7989 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7990 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7991 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7992 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7993 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7994 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7995 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7996 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7997 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7998 	{ } /* end */
7999 };
8000 
8001 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8002 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8003 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8004 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8005 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8006 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8007 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8008 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8009 	HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8010 	HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8011 	{ } /* end */
8012 };
8013 
8014 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8015 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8016 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8017 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8018 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8019 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8020 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8021 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8022 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8023 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8024 	{ } /* end */
8025 };
8026 
8027 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8028 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8029 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8030 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8031 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8032 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8033 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8034 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8035 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8036 	{ } /* end */
8037 };
8038 
8039 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8040 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8041 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8042 	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8043 	HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8044 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8045 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8046 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8047 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8048 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8049 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8050 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8051 	{ } /* end */
8052 };
8053 
8054 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8055 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8056 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8057 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8058 	HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8059 	HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8060 						0x0d, 1, 0x0, HDA_OUTPUT),
8061 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8062 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8063 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8064 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8065 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8066 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8067 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8068 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8069 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8070 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8071 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8072 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8073 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8074 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8075 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8076 	{ } /* end */
8077 };
8078 
8079 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8080 	/* Output mixers */
8081 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8082 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8083 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8084 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8085 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8086 		HDA_OUTPUT),
8087 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8088 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8089 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8090 	/* Output switches */
8091 	HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8092 	HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8093 	HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8094 	/* Boost mixers */
8095 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8096 	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8097 	/* Input mixers */
8098 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8099 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8100 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8101 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8102 	{ } /* end */
8103 };
8104 
8105 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8106 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8107 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8108 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8109 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8110 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8111 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8112 	{ } /* end */
8113 };
8114 
8115 static struct hda_bind_ctls alc883_bind_cap_vol = {
8116 	.ops = &snd_hda_bind_vol,
8117 	.values = {
8118 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8119 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8120 		0
8121 	},
8122 };
8123 
8124 static struct hda_bind_ctls alc883_bind_cap_switch = {
8125 	.ops = &snd_hda_bind_sw,
8126 	.values = {
8127 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8128 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8129 		0
8130 	},
8131 };
8132 
8133 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8134 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8135 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8136 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8137 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8138 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8139 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8140 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8141 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8142 	{ } /* end */
8143 };
8144 
8145 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8146 	HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8147 	HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8148 	{
8149 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8150 		/* .name = "Capture Source", */
8151 		.name = "Input Source",
8152 		.count = 1,
8153 		.info = alc_mux_enum_info,
8154 		.get = alc_mux_enum_get,
8155 		.put = alc_mux_enum_put,
8156 	},
8157 	{ } /* end */
8158 };
8159 
8160 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8161 	{
8162 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8163 		.name = "Channel Mode",
8164 		.info = alc_ch_mode_info,
8165 		.get = alc_ch_mode_get,
8166 		.put = alc_ch_mode_put,
8167 	},
8168 	{ } /* end */
8169 };
8170 
8171 /* toggle speaker-output according to the hp-jack state */
8172 static void alc883_mitac_setup(struct hda_codec *codec)
8173 {
8174 	struct alc_spec *spec = codec->spec;
8175 
8176 	spec->autocfg.hp_pins[0] = 0x15;
8177 	spec->autocfg.speaker_pins[0] = 0x14;
8178 	spec->autocfg.speaker_pins[1] = 0x17;
8179 }
8180 
8181 /* auto-toggle front mic */
8182 /*
8183 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8184 {
8185 	unsigned int present;
8186 	unsigned char bits;
8187 
8188 	present = snd_hda_codec_read(codec, 0x18, 0,
8189 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8190 	bits = present ? HDA_AMP_MUTE : 0;
8191 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8192 }
8193 */
8194 
8195 static struct hda_verb alc883_mitac_verbs[] = {
8196 	/* HP */
8197 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8198 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8199 	/* Subwoofer */
8200 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8201 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8202 
8203 	/* enable unsolicited event */
8204 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8205 	/* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8206 
8207 	{ } /* end */
8208 };
8209 
8210 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8211 	/* HP */
8212 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8213 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8214 	/* Int speaker */
8215 	/*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8216 
8217 	/* enable unsolicited event */
8218 	/*
8219 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8220 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8221 	*/
8222 
8223 	{ } /* end */
8224 };
8225 
8226 static struct hda_verb alc883_clevo_m720_verbs[] = {
8227 	/* HP */
8228 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8229 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8230 	/* Int speaker */
8231 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8232 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8233 
8234 	/* enable unsolicited event */
8235 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8236 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8237 
8238 	{ } /* end */
8239 };
8240 
8241 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8242 	/* HP */
8243 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8244 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8245 	/* Subwoofer */
8246 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8247 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8248 
8249 	/* enable unsolicited event */
8250 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8251 
8252 	{ } /* end */
8253 };
8254 
8255 static struct hda_verb alc883_targa_verbs[] = {
8256 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8257 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8258 
8259 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8260 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8261 
8262 /* Connect Line-Out side jack (SPDIF) to Side */
8263 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8264 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8265 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8266 /* Connect Mic jack to CLFE */
8267 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8268 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8269 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8270 /* Connect Line-in jack to Surround */
8271 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8272 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8273 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8274 /* Connect HP out jack to Front */
8275 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8276 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8277 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8278 
8279 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8280 
8281 	{ } /* end */
8282 };
8283 
8284 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8285 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8286 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8287         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8288 	{ } /* end */
8289 };
8290 
8291 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8292         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8293 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8294         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8295         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8296 	{ } /* end */
8297 };
8298 
8299 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8300 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8301 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8302 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8303 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8304 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8305 	{ } /* end */
8306 };
8307 
8308 static struct hda_verb alc883_haier_w66_verbs[] = {
8309 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8310 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8311 
8312 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8313 
8314 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8315 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8316 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8317 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8318 	{ } /* end */
8319 };
8320 
8321 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8322 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8323 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8324 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8325 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8326 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8327 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8328 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8329 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8330 	{ } /* end */
8331 };
8332 
8333 static struct hda_verb alc888_6st_dell_verbs[] = {
8334 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8335 	{ }
8336 };
8337 
8338 static struct hda_verb alc883_vaiott_verbs[] = {
8339 	/* HP */
8340 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8341 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8342 
8343 	/* enable unsolicited event */
8344 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8345 
8346 	{ } /* end */
8347 };
8348 
8349 static void alc888_3st_hp_setup(struct hda_codec *codec)
8350 {
8351 	struct alc_spec *spec = codec->spec;
8352 
8353 	spec->autocfg.hp_pins[0] = 0x1b;
8354 	spec->autocfg.speaker_pins[0] = 0x14;
8355 	spec->autocfg.speaker_pins[1] = 0x16;
8356 	spec->autocfg.speaker_pins[2] = 0x18;
8357 }
8358 
8359 static struct hda_verb alc888_3st_hp_verbs[] = {
8360 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Front: output 0 (0x0c) */
8361 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Rear : output 1 (0x0d) */
8362 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},	/* CLFE : output 2 (0x0e) */
8363 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8364 	{ } /* end */
8365 };
8366 
8367 /*
8368  * 2ch mode
8369  */
8370 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8371 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8372 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8373 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8374 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8375 	{ } /* end */
8376 };
8377 
8378 /*
8379  * 4ch mode
8380  */
8381 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8382 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8383 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8384 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8385 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8386 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8387 	{ } /* end */
8388 };
8389 
8390 /*
8391  * 6ch mode
8392  */
8393 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8394 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8395 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8396 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8397 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8398 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8399 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8400 	{ } /* end */
8401 };
8402 
8403 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8404 	{ 2, alc888_3st_hp_2ch_init },
8405 	{ 4, alc888_3st_hp_4ch_init },
8406 	{ 6, alc888_3st_hp_6ch_init },
8407 };
8408 
8409 /* toggle front-jack and RCA according to the hp-jack state */
8410 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8411 {
8412  	unsigned int present;
8413 
8414  	present = snd_hda_codec_read(codec, 0x1b, 0,
8415 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8416 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8417 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8418 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8419 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8420 }
8421 
8422 /* toggle RCA according to the front-jack state */
8423 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8424 {
8425  	unsigned int present;
8426 
8427  	present = snd_hda_codec_read(codec, 0x14, 0,
8428 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8429 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8430 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8431 }
8432 
8433 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8434 					     unsigned int res)
8435 {
8436 	if ((res >> 26) == ALC880_HP_EVENT)
8437 		alc888_lenovo_ms7195_front_automute(codec);
8438 	if ((res >> 26) == ALC880_FRONT_EVENT)
8439 		alc888_lenovo_ms7195_rca_automute(codec);
8440 }
8441 
8442 static struct hda_verb alc883_medion_md2_verbs[] = {
8443 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8444 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8445 
8446 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8447 
8448 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8449 	{ } /* end */
8450 };
8451 
8452 /* toggle speaker-output according to the hp-jack state */
8453 static void alc883_medion_md2_setup(struct hda_codec *codec)
8454 {
8455 	struct alc_spec *spec = codec->spec;
8456 
8457 	spec->autocfg.hp_pins[0] = 0x14;
8458 	spec->autocfg.speaker_pins[0] = 0x15;
8459 }
8460 
8461 /* toggle speaker-output according to the hp-jack state */
8462 #define alc883_targa_init_hook		alc882_targa_init_hook
8463 #define alc883_targa_unsol_event	alc882_targa_unsol_event
8464 
8465 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8466 {
8467 	unsigned int present;
8468 
8469 	present = snd_hda_codec_read(codec, 0x18, 0,
8470 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8471 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8472 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8473 }
8474 
8475 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8476 {
8477 	struct alc_spec *spec = codec->spec;
8478 
8479 	spec->autocfg.hp_pins[0] = 0x15;
8480 	spec->autocfg.speaker_pins[0] = 0x14;
8481 }
8482 
8483 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8484 {
8485 	alc_automute_amp(codec);
8486 	alc883_clevo_m720_mic_automute(codec);
8487 }
8488 
8489 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8490 					   unsigned int res)
8491 {
8492 	switch (res >> 26) {
8493 	case ALC880_MIC_EVENT:
8494 		alc883_clevo_m720_mic_automute(codec);
8495 		break;
8496 	default:
8497 		alc_automute_amp_unsol_event(codec, res);
8498 		break;
8499 	}
8500 }
8501 
8502 /* toggle speaker-output according to the hp-jack state */
8503 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8504 {
8505 	struct alc_spec *spec = codec->spec;
8506 
8507 	spec->autocfg.hp_pins[0] = 0x14;
8508 	spec->autocfg.speaker_pins[0] = 0x15;
8509 }
8510 
8511 static void alc883_haier_w66_setup(struct hda_codec *codec)
8512 {
8513 	struct alc_spec *spec = codec->spec;
8514 
8515 	spec->autocfg.hp_pins[0] = 0x1b;
8516 	spec->autocfg.speaker_pins[0] = 0x14;
8517 }
8518 
8519 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8520 {
8521  	unsigned int present;
8522 	unsigned char bits;
8523 
8524 	present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8525 		& AC_PINSENSE_PRESENCE;
8526 	bits = present ? HDA_AMP_MUTE : 0;
8527 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8528 				 HDA_AMP_MUTE, bits);
8529 }
8530 
8531 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8532 {
8533  	unsigned int present;
8534 	unsigned char bits;
8535 
8536  	present = snd_hda_codec_read(codec, 0x1b, 0,
8537 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8538 	bits = present ? HDA_AMP_MUTE : 0;
8539 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8540 				 HDA_AMP_MUTE, bits);
8541 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8542 				 HDA_AMP_MUTE, bits);
8543 }
8544 
8545 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8546 					   unsigned int res)
8547 {
8548 	if ((res >> 26) == ALC880_HP_EVENT)
8549 		alc883_lenovo_101e_all_automute(codec);
8550 	if ((res >> 26) == ALC880_FRONT_EVENT)
8551 		alc883_lenovo_101e_ispeaker_automute(codec);
8552 }
8553 
8554 /* toggle speaker-output according to the hp-jack state */
8555 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8556 {
8557 	struct alc_spec *spec = codec->spec;
8558 
8559 	spec->autocfg.hp_pins[0] = 0x14;
8560 	spec->autocfg.speaker_pins[0] = 0x15;
8561 	spec->autocfg.speaker_pins[1] = 0x16;
8562 }
8563 
8564 static struct hda_verb alc883_acer_eapd_verbs[] = {
8565 	/* HP Pin: output 0 (0x0c) */
8566 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8567 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8568 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8569 	/* Front Pin: output 0 (0x0c) */
8570 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8571 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8572 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8573 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8574         /* eanable EAPD on medion laptop */
8575 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8576 	{0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8577 	/* enable unsolicited event */
8578 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8579 	{ }
8580 };
8581 
8582 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8583 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8584 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8585 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8586 	{ } /* end */
8587 };
8588 
8589 static void alc888_6st_dell_setup(struct hda_codec *codec)
8590 {
8591 	struct alc_spec *spec = codec->spec;
8592 
8593 	spec->autocfg.hp_pins[0] = 0x1b;
8594 	spec->autocfg.speaker_pins[0] = 0x14;
8595 	spec->autocfg.speaker_pins[1] = 0x15;
8596 	spec->autocfg.speaker_pins[2] = 0x16;
8597 	spec->autocfg.speaker_pins[3] = 0x17;
8598 }
8599 
8600 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
8601 {
8602 	struct alc_spec *spec = codec->spec;
8603 
8604 	spec->autocfg.hp_pins[0] = 0x1b;
8605 	spec->autocfg.speaker_pins[0] = 0x14;
8606 	spec->autocfg.speaker_pins[1] = 0x15;
8607 	spec->autocfg.speaker_pins[2] = 0x16;
8608 	spec->autocfg.speaker_pins[3] = 0x17;
8609 	spec->autocfg.speaker_pins[4] = 0x1a;
8610 }
8611 
8612 static void alc883_vaiott_setup(struct hda_codec *codec)
8613 {
8614 	struct alc_spec *spec = codec->spec;
8615 
8616 	spec->autocfg.hp_pins[0] = 0x15;
8617 	spec->autocfg.speaker_pins[0] = 0x14;
8618 	spec->autocfg.speaker_pins[1] = 0x17;
8619 }
8620 
8621 static struct hda_verb alc888_asus_m90v_verbs[] = {
8622 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8623 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8624 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8625 	/* enable unsolicited event */
8626 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8627 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8628 	{ } /* end */
8629 };
8630 
8631 static void alc883_mode2_setup(struct hda_codec *codec)
8632 {
8633 	struct alc_spec *spec = codec->spec;
8634 
8635 	spec->autocfg.hp_pins[0] = 0x1b;
8636 	spec->autocfg.speaker_pins[0] = 0x14;
8637 	spec->autocfg.speaker_pins[1] = 0x15;
8638 	spec->autocfg.speaker_pins[2] = 0x16;
8639 	spec->ext_mic.pin = 0x18;
8640 	spec->int_mic.pin = 0x19;
8641 	spec->ext_mic.mux_idx = 0;
8642 	spec->int_mic.mux_idx = 1;
8643 	spec->auto_mic = 1;
8644 }
8645 
8646 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8647 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8648 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8649 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8650 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8651 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8652 	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8653 	{0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8654 	/* enable unsolicited event */
8655 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8656 	{ } /* end */
8657 };
8658 
8659 static void alc883_eee1601_inithook(struct hda_codec *codec)
8660 {
8661 	struct alc_spec *spec = codec->spec;
8662 
8663 	spec->autocfg.hp_pins[0] = 0x14;
8664 	spec->autocfg.speaker_pins[0] = 0x1b;
8665 	alc_automute_pin(codec);
8666 }
8667 
8668 static struct hda_verb alc889A_mb31_verbs[] = {
8669 	/* Init rear pin (used as headphone output) */
8670 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8671 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8672 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8673 	/* Init line pin (used as output in 4ch and 6ch mode) */
8674 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8675 	/* Init line 2 pin (used as headphone out by default) */
8676 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8677 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8678 	{ } /* end */
8679 };
8680 
8681 /* Mute speakers according to the headphone jack state */
8682 static void alc889A_mb31_automute(struct hda_codec *codec)
8683 {
8684 	unsigned int present;
8685 
8686 	/* Mute only in 2ch or 4ch mode */
8687 	if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8688 	    == 0x00) {
8689 		present = snd_hda_codec_read(codec, 0x15, 0,
8690 			AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
8691 		snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8692 			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8693 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8694 			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8695 	}
8696 }
8697 
8698 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8699 {
8700 	if ((res >> 26) == ALC880_HP_EVENT)
8701 		alc889A_mb31_automute(codec);
8702 }
8703 
8704 
8705 #ifdef CONFIG_SND_HDA_POWER_SAVE
8706 #define alc882_loopbacks	alc880_loopbacks
8707 #endif
8708 
8709 /* pcm configuration: identical with ALC880 */
8710 #define alc882_pcm_analog_playback	alc880_pcm_analog_playback
8711 #define alc882_pcm_analog_capture	alc880_pcm_analog_capture
8712 #define alc882_pcm_digital_playback	alc880_pcm_digital_playback
8713 #define alc882_pcm_digital_capture	alc880_pcm_digital_capture
8714 
8715 static hda_nid_t alc883_slave_dig_outs[] = {
8716 	ALC1200_DIGOUT_NID, 0,
8717 };
8718 
8719 static hda_nid_t alc1200_slave_dig_outs[] = {
8720 	ALC883_DIGOUT_NID, 0,
8721 };
8722 
8723 /*
8724  * configuration and preset
8725  */
8726 static const char *alc882_models[ALC882_MODEL_LAST] = {
8727 	[ALC882_3ST_DIG]	= "3stack-dig",
8728 	[ALC882_6ST_DIG]	= "6stack-dig",
8729 	[ALC882_ARIMA]		= "arima",
8730 	[ALC882_W2JC]		= "w2jc",
8731 	[ALC882_TARGA]		= "targa",
8732 	[ALC882_ASUS_A7J]	= "asus-a7j",
8733 	[ALC882_ASUS_A7M]	= "asus-a7m",
8734 	[ALC885_MACPRO]		= "macpro",
8735 	[ALC885_MB5]		= "mb5",
8736 	[ALC885_MBP3]		= "mbp3",
8737 	[ALC885_IMAC24]		= "imac24",
8738 	[ALC883_3ST_2ch_DIG]	= "3stack-2ch-dig",
8739 	[ALC883_3ST_6ch_DIG]	= "3stack-6ch-dig",
8740 	[ALC883_3ST_6ch]	= "3stack-6ch",
8741 	[ALC883_6ST_DIG]	= "alc883-6stack-dig",
8742 	[ALC883_TARGA_DIG]	= "targa-dig",
8743 	[ALC883_TARGA_2ch_DIG]	= "targa-2ch-dig",
8744 	[ALC883_TARGA_8ch_DIG]	= "targa-8ch-dig",
8745 	[ALC883_ACER]		= "acer",
8746 	[ALC883_ACER_ASPIRE]	= "acer-aspire",
8747 	[ALC888_ACER_ASPIRE_4930G]	= "acer-aspire-4930g",
8748 	[ALC888_ACER_ASPIRE_6530G]	= "acer-aspire-6530g",
8749 	[ALC888_ACER_ASPIRE_8930G]	= "acer-aspire-8930g",
8750 	[ALC888_ACER_ASPIRE_7730G]	= "acer-aspire-7730g",
8751 	[ALC883_MEDION]		= "medion",
8752 	[ALC883_MEDION_MD2]	= "medion-md2",
8753 	[ALC883_LAPTOP_EAPD]	= "laptop-eapd",
8754 	[ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8755 	[ALC883_LENOVO_NB0763]	= "lenovo-nb0763",
8756 	[ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8757 	[ALC888_LENOVO_SKY] = "lenovo-sky",
8758 	[ALC883_HAIER_W66] 	= "haier-w66",
8759 	[ALC888_3ST_HP]		= "3stack-hp",
8760 	[ALC888_6ST_DELL]	= "6stack-dell",
8761 	[ALC883_MITAC]		= "mitac",
8762 	[ALC883_CLEVO_M540R]	= "clevo-m540r",
8763 	[ALC883_CLEVO_M720]	= "clevo-m720",
8764 	[ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8765 	[ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8766 	[ALC883_3ST_6ch_INTEL]	= "3stack-6ch-intel",
8767 	[ALC889A_INTEL]		= "intel-alc889a",
8768 	[ALC889_INTEL]		= "intel-x58",
8769 	[ALC1200_ASUS_P5Q]	= "asus-p5q",
8770 	[ALC889A_MB31]		= "mb31",
8771 	[ALC883_SONY_VAIO_TT]	= "sony-vaio-tt",
8772 	[ALC882_AUTO]		= "auto",
8773 };
8774 
8775 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8776 	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8777 
8778 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8779 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8780 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8781 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8782 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8783 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8784 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8785 		ALC888_ACER_ASPIRE_4930G),
8786 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8787 		ALC888_ACER_ASPIRE_4930G),
8788 	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8789 		ALC888_ACER_ASPIRE_8930G),
8790 	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8791 		ALC888_ACER_ASPIRE_8930G),
8792 	SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8793 	SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8794 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8795 		ALC888_ACER_ASPIRE_6530G),
8796 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8797 		ALC888_ACER_ASPIRE_6530G),
8798 	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
8799 		ALC888_ACER_ASPIRE_7730G),
8800 	/* default Acer -- disabled as it causes more problems.
8801 	 *    model=auto should work fine now
8802 	 */
8803 	/* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8804 
8805 	SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8806 
8807 	SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8808 	SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8809 	SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8810 	SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8811 	SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8812 	SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8813 
8814 	SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8815 	SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8816 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8817 	SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8818 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8819 	SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8820 	SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8821 	SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8822 	SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8823 	SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8824 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8825 
8826 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8827 	SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8828 	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8829 	SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8830 	SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8831 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8832 	SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8833 	SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8834 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8835 
8836 	SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8837 	SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8838 	SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8839 	SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8840 	SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8841 	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8842 	SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8843 	SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8844 	SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8845 	SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8846 	SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8847 	SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8848 	SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8849 	SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8850 	SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8851 	SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8852 	SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8853 	SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8854 	SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8855 	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8856 	SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8857 	SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8858 	SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8859 	SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8860 	SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8861 	SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8862 	SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8863 	SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8864 	SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8865 
8866 	SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8867 	SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8868 	SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8869 	SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
8870 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8871 	SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8872 	/* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
8873 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8874 	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8875 		      ALC883_FUJITSU_PI2515),
8876 	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8877 		ALC888_FUJITSU_XA3530),
8878 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8879 	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8880 	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8881 	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8882 	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8883 	SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8884 	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8885 	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8886 	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8887 
8888 	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8889 	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8890 	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8891 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
8892 	SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
8893 	SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
8894 	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8895 
8896 	{}
8897 };
8898 
8899 /* codec SSID table for Intel Mac */
8900 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
8901 	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
8902 	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
8903 	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
8904 	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
8905 	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
8906 	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
8907 	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
8908 	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
8909 	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
8910 	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
8911 	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
8912 	/* FIXME: HP jack sense seems not working for MBP 5,1, so apparently
8913 	 * no perfect solution yet
8914 	 */
8915 	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
8916 	{} /* terminator */
8917 };
8918 
8919 static struct alc_config_preset alc882_presets[] = {
8920 	[ALC882_3ST_DIG] = {
8921 		.mixers = { alc882_base_mixer },
8922 		.init_verbs = { alc882_base_init_verbs,
8923 				alc882_adc1_init_verbs },
8924 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
8925 		.dac_nids = alc882_dac_nids,
8926 		.dig_out_nid = ALC882_DIGOUT_NID,
8927 		.dig_in_nid = ALC882_DIGIN_NID,
8928 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8929 		.channel_mode = alc882_ch_modes,
8930 		.need_dac_fix = 1,
8931 		.input_mux = &alc882_capture_source,
8932 	},
8933 	[ALC882_6ST_DIG] = {
8934 		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
8935 		.init_verbs = { alc882_base_init_verbs,
8936 				alc882_adc1_init_verbs },
8937 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
8938 		.dac_nids = alc882_dac_nids,
8939 		.dig_out_nid = ALC882_DIGOUT_NID,
8940 		.dig_in_nid = ALC882_DIGIN_NID,
8941 		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8942 		.channel_mode = alc882_sixstack_modes,
8943 		.input_mux = &alc882_capture_source,
8944 	},
8945 	[ALC882_ARIMA] = {
8946 		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
8947 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8948 				alc882_eapd_verbs },
8949 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
8950 		.dac_nids = alc882_dac_nids,
8951 		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8952 		.channel_mode = alc882_sixstack_modes,
8953 		.input_mux = &alc882_capture_source,
8954 	},
8955 	[ALC882_W2JC] = {
8956 		.mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
8957 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8958 				alc882_eapd_verbs, alc880_gpio1_init_verbs },
8959 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
8960 		.dac_nids = alc882_dac_nids,
8961 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8962 		.channel_mode = alc880_threestack_modes,
8963 		.need_dac_fix = 1,
8964 		.input_mux = &alc882_capture_source,
8965 		.dig_out_nid = ALC882_DIGOUT_NID,
8966 	},
8967 	[ALC885_MBP3] = {
8968 		.mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
8969 		.init_verbs = { alc885_mbp3_init_verbs,
8970 				alc880_gpio1_init_verbs },
8971 		.num_dacs = 2,
8972 		.dac_nids = alc882_dac_nids,
8973 		.hp_nid = 0x04,
8974 		.channel_mode = alc885_mbp_4ch_modes,
8975 		.num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
8976 		.input_mux = &alc882_capture_source,
8977 		.dig_out_nid = ALC882_DIGOUT_NID,
8978 		.dig_in_nid = ALC882_DIGIN_NID,
8979 		.unsol_event = alc_automute_amp_unsol_event,
8980 		.setup = alc885_mbp3_setup,
8981 		.init_hook = alc_automute_amp,
8982 	},
8983 	[ALC885_MB5] = {
8984 		.mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
8985 		.init_verbs = { alc885_mb5_init_verbs,
8986 				alc880_gpio1_init_verbs },
8987 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
8988 		.dac_nids = alc882_dac_nids,
8989 		.channel_mode = alc885_mb5_6ch_modes,
8990 		.num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
8991 		.input_mux = &mb5_capture_source,
8992 		.dig_out_nid = ALC882_DIGOUT_NID,
8993 		.dig_in_nid = ALC882_DIGIN_NID,
8994 	},
8995 	[ALC885_MACPRO] = {
8996 		.mixers = { alc882_macpro_mixer },
8997 		.init_verbs = { alc882_macpro_init_verbs },
8998 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
8999 		.dac_nids = alc882_dac_nids,
9000 		.dig_out_nid = ALC882_DIGOUT_NID,
9001 		.dig_in_nid = ALC882_DIGIN_NID,
9002 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9003 		.channel_mode = alc882_ch_modes,
9004 		.input_mux = &alc882_capture_source,
9005 		.init_hook = alc885_macpro_init_hook,
9006 	},
9007 	[ALC885_IMAC24] = {
9008 		.mixers = { alc885_imac24_mixer },
9009 		.init_verbs = { alc885_imac24_init_verbs },
9010 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9011 		.dac_nids = alc882_dac_nids,
9012 		.dig_out_nid = ALC882_DIGOUT_NID,
9013 		.dig_in_nid = ALC882_DIGIN_NID,
9014 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9015 		.channel_mode = alc882_ch_modes,
9016 		.input_mux = &alc882_capture_source,
9017 		.unsol_event = alc_automute_amp_unsol_event,
9018 		.setup = alc885_imac24_setup,
9019 		.init_hook = alc885_imac24_init_hook,
9020 	},
9021 	[ALC882_TARGA] = {
9022 		.mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9023 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9024 				alc880_gpio3_init_verbs, alc882_targa_verbs},
9025 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9026 		.dac_nids = alc882_dac_nids,
9027 		.dig_out_nid = ALC882_DIGOUT_NID,
9028 		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9029 		.adc_nids = alc882_adc_nids,
9030 		.capsrc_nids = alc882_capsrc_nids,
9031 		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9032 		.channel_mode = alc882_3ST_6ch_modes,
9033 		.need_dac_fix = 1,
9034 		.input_mux = &alc882_capture_source,
9035 		.unsol_event = alc882_targa_unsol_event,
9036 		.setup = alc882_targa_setup,
9037 		.init_hook = alc882_targa_automute,
9038 	},
9039 	[ALC882_ASUS_A7J] = {
9040 		.mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9041 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9042 				alc882_asus_a7j_verbs},
9043 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9044 		.dac_nids = alc882_dac_nids,
9045 		.dig_out_nid = ALC882_DIGOUT_NID,
9046 		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9047 		.adc_nids = alc882_adc_nids,
9048 		.capsrc_nids = alc882_capsrc_nids,
9049 		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9050 		.channel_mode = alc882_3ST_6ch_modes,
9051 		.need_dac_fix = 1,
9052 		.input_mux = &alc882_capture_source,
9053 	},
9054 	[ALC882_ASUS_A7M] = {
9055 		.mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9056 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9057 				alc882_eapd_verbs, alc880_gpio1_init_verbs,
9058 				alc882_asus_a7m_verbs },
9059 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9060 		.dac_nids = alc882_dac_nids,
9061 		.dig_out_nid = ALC882_DIGOUT_NID,
9062 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9063 		.channel_mode = alc880_threestack_modes,
9064 		.need_dac_fix = 1,
9065 		.input_mux = &alc882_capture_source,
9066 	},
9067 	[ALC883_3ST_2ch_DIG] = {
9068 		.mixers = { alc883_3ST_2ch_mixer },
9069 		.init_verbs = { alc883_init_verbs },
9070 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9071 		.dac_nids = alc883_dac_nids,
9072 		.dig_out_nid = ALC883_DIGOUT_NID,
9073 		.dig_in_nid = ALC883_DIGIN_NID,
9074 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9075 		.channel_mode = alc883_3ST_2ch_modes,
9076 		.input_mux = &alc883_capture_source,
9077 	},
9078 	[ALC883_3ST_6ch_DIG] = {
9079 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9080 		.init_verbs = { alc883_init_verbs },
9081 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9082 		.dac_nids = alc883_dac_nids,
9083 		.dig_out_nid = ALC883_DIGOUT_NID,
9084 		.dig_in_nid = ALC883_DIGIN_NID,
9085 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9086 		.channel_mode = alc883_3ST_6ch_modes,
9087 		.need_dac_fix = 1,
9088 		.input_mux = &alc883_capture_source,
9089 	},
9090 	[ALC883_3ST_6ch] = {
9091 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9092 		.init_verbs = { alc883_init_verbs },
9093 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9094 		.dac_nids = alc883_dac_nids,
9095 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9096 		.channel_mode = alc883_3ST_6ch_modes,
9097 		.need_dac_fix = 1,
9098 		.input_mux = &alc883_capture_source,
9099 	},
9100 	[ALC883_3ST_6ch_INTEL] = {
9101 		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9102 		.init_verbs = { alc883_init_verbs },
9103 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9104 		.dac_nids = alc883_dac_nids,
9105 		.dig_out_nid = ALC883_DIGOUT_NID,
9106 		.dig_in_nid = ALC883_DIGIN_NID,
9107 		.slave_dig_outs = alc883_slave_dig_outs,
9108 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9109 		.channel_mode = alc883_3ST_6ch_intel_modes,
9110 		.need_dac_fix = 1,
9111 		.input_mux = &alc883_3stack_6ch_intel,
9112 	},
9113 	[ALC889A_INTEL] = {
9114 		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9115 		.init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9116 				alc_hp15_unsol_verbs },
9117 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9118 		.dac_nids = alc883_dac_nids,
9119 		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9120 		.adc_nids = alc889_adc_nids,
9121 		.dig_out_nid = ALC883_DIGOUT_NID,
9122 		.dig_in_nid = ALC883_DIGIN_NID,
9123 		.slave_dig_outs = alc883_slave_dig_outs,
9124 		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9125 		.channel_mode = alc889_8ch_intel_modes,
9126 		.capsrc_nids = alc889_capsrc_nids,
9127 		.input_mux = &alc889_capture_source,
9128 		.setup = alc889_automute_setup,
9129 		.init_hook = alc_automute_amp,
9130 		.unsol_event = alc_automute_amp_unsol_event,
9131 		.need_dac_fix = 1,
9132 	},
9133 	[ALC889_INTEL] = {
9134 		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9135 		.init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9136 				alc889_eapd_verbs, alc_hp15_unsol_verbs},
9137 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9138 		.dac_nids = alc883_dac_nids,
9139 		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9140 		.adc_nids = alc889_adc_nids,
9141 		.dig_out_nid = ALC883_DIGOUT_NID,
9142 		.dig_in_nid = ALC883_DIGIN_NID,
9143 		.slave_dig_outs = alc883_slave_dig_outs,
9144 		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9145 		.channel_mode = alc889_8ch_intel_modes,
9146 		.capsrc_nids = alc889_capsrc_nids,
9147 		.input_mux = &alc889_capture_source,
9148 		.setup = alc889_automute_setup,
9149 		.init_hook = alc889_intel_init_hook,
9150 		.unsol_event = alc_automute_amp_unsol_event,
9151 		.need_dac_fix = 1,
9152 	},
9153 	[ALC883_6ST_DIG] = {
9154 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9155 		.init_verbs = { alc883_init_verbs },
9156 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9157 		.dac_nids = alc883_dac_nids,
9158 		.dig_out_nid = ALC883_DIGOUT_NID,
9159 		.dig_in_nid = ALC883_DIGIN_NID,
9160 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9161 		.channel_mode = alc883_sixstack_modes,
9162 		.input_mux = &alc883_capture_source,
9163 	},
9164 	[ALC883_TARGA_DIG] = {
9165 		.mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9166 		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9167 				alc883_targa_verbs},
9168 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9169 		.dac_nids = alc883_dac_nids,
9170 		.dig_out_nid = ALC883_DIGOUT_NID,
9171 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9172 		.channel_mode = alc883_3ST_6ch_modes,
9173 		.need_dac_fix = 1,
9174 		.input_mux = &alc883_capture_source,
9175 		.unsol_event = alc883_targa_unsol_event,
9176 		.setup = alc882_targa_setup,
9177 		.init_hook = alc882_targa_automute,
9178 	},
9179 	[ALC883_TARGA_2ch_DIG] = {
9180 		.mixers = { alc883_targa_2ch_mixer},
9181 		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9182 				alc883_targa_verbs},
9183 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9184 		.dac_nids = alc883_dac_nids,
9185 		.adc_nids = alc883_adc_nids_alt,
9186 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9187 		.dig_out_nid = ALC883_DIGOUT_NID,
9188 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9189 		.channel_mode = alc883_3ST_2ch_modes,
9190 		.input_mux = &alc883_capture_source,
9191 		.unsol_event = alc883_targa_unsol_event,
9192 		.setup = alc882_targa_setup,
9193 		.init_hook = alc882_targa_automute,
9194 	},
9195 	[ALC883_TARGA_8ch_DIG] = {
9196 		.mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9197 			    alc883_chmode_mixer },
9198 		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9199 				alc883_targa_verbs },
9200 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9201 		.dac_nids = alc883_dac_nids,
9202 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9203 		.adc_nids = alc883_adc_nids_rev,
9204 		.capsrc_nids = alc883_capsrc_nids_rev,
9205 		.dig_out_nid = ALC883_DIGOUT_NID,
9206 		.dig_in_nid = ALC883_DIGIN_NID,
9207 		.num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9208 		.channel_mode = alc883_4ST_8ch_modes,
9209 		.need_dac_fix = 1,
9210 		.input_mux = &alc883_capture_source,
9211 		.unsol_event = alc883_targa_unsol_event,
9212 		.setup = alc882_targa_setup,
9213 		.init_hook = alc882_targa_automute,
9214 	},
9215 	[ALC883_ACER] = {
9216 		.mixers = { alc883_base_mixer },
9217 		/* On TravelMate laptops, GPIO 0 enables the internal speaker
9218 		 * and the headphone jack.  Turn this on and rely on the
9219 		 * standard mute methods whenever the user wants to turn
9220 		 * these outputs off.
9221 		 */
9222 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9223 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9224 		.dac_nids = alc883_dac_nids,
9225 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9226 		.channel_mode = alc883_3ST_2ch_modes,
9227 		.input_mux = &alc883_capture_source,
9228 	},
9229 	[ALC883_ACER_ASPIRE] = {
9230 		.mixers = { alc883_acer_aspire_mixer },
9231 		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9232 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9233 		.dac_nids = alc883_dac_nids,
9234 		.dig_out_nid = ALC883_DIGOUT_NID,
9235 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9236 		.channel_mode = alc883_3ST_2ch_modes,
9237 		.input_mux = &alc883_capture_source,
9238 		.unsol_event = alc_automute_amp_unsol_event,
9239 		.setup = alc883_acer_aspire_setup,
9240 		.init_hook = alc_automute_amp,
9241 	},
9242 	[ALC888_ACER_ASPIRE_4930G] = {
9243 		.mixers = { alc888_base_mixer,
9244 				alc883_chmode_mixer },
9245 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9246 				alc888_acer_aspire_4930g_verbs },
9247 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9248 		.dac_nids = alc883_dac_nids,
9249 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9250 		.adc_nids = alc883_adc_nids_rev,
9251 		.capsrc_nids = alc883_capsrc_nids_rev,
9252 		.dig_out_nid = ALC883_DIGOUT_NID,
9253 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9254 		.channel_mode = alc883_3ST_6ch_modes,
9255 		.need_dac_fix = 1,
9256 		.num_mux_defs =
9257 			ARRAY_SIZE(alc888_2_capture_sources),
9258 		.input_mux = alc888_2_capture_sources,
9259 		.unsol_event = alc_automute_amp_unsol_event,
9260 		.setup = alc888_acer_aspire_4930g_setup,
9261 		.init_hook = alc_automute_amp,
9262 	},
9263 	[ALC888_ACER_ASPIRE_6530G] = {
9264 		.mixers = { alc888_acer_aspire_6530_mixer },
9265 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9266 				alc888_acer_aspire_6530g_verbs },
9267 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9268 		.dac_nids = alc883_dac_nids,
9269 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9270 		.adc_nids = alc883_adc_nids_rev,
9271 		.capsrc_nids = alc883_capsrc_nids_rev,
9272 		.dig_out_nid = ALC883_DIGOUT_NID,
9273 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9274 		.channel_mode = alc883_3ST_2ch_modes,
9275 		.num_mux_defs =
9276 			ARRAY_SIZE(alc888_2_capture_sources),
9277 		.input_mux = alc888_acer_aspire_6530_sources,
9278 		.unsol_event = alc_automute_amp_unsol_event,
9279 		.setup = alc888_acer_aspire_6530g_setup,
9280 		.init_hook = alc_automute_amp,
9281 	},
9282 	[ALC888_ACER_ASPIRE_8930G] = {
9283 		.mixers = { alc888_base_mixer,
9284 				alc883_chmode_mixer },
9285 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9286 				alc889_acer_aspire_8930g_verbs },
9287 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9288 		.dac_nids = alc883_dac_nids,
9289 		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9290 		.adc_nids = alc889_adc_nids,
9291 		.capsrc_nids = alc889_capsrc_nids,
9292 		.dig_out_nid = ALC883_DIGOUT_NID,
9293 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9294 		.channel_mode = alc883_3ST_6ch_modes,
9295 		.need_dac_fix = 1,
9296 		.const_channel_count = 6,
9297 		.num_mux_defs =
9298 			ARRAY_SIZE(alc889_capture_sources),
9299 		.input_mux = alc889_capture_sources,
9300 		.unsol_event = alc_automute_amp_unsol_event,
9301 		.setup = alc889_acer_aspire_8930g_setup,
9302 		.init_hook = alc_automute_amp,
9303 	},
9304 	[ALC888_ACER_ASPIRE_7730G] = {
9305 		.mixers = { alc883_3ST_6ch_mixer,
9306 				alc883_chmode_mixer },
9307 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9308 				alc888_acer_aspire_7730G_verbs },
9309 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9310 		.dac_nids = alc883_dac_nids,
9311 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9312 		.adc_nids = alc883_adc_nids_rev,
9313 		.capsrc_nids = alc883_capsrc_nids_rev,
9314 		.dig_out_nid = ALC883_DIGOUT_NID,
9315 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9316 		.channel_mode = alc883_3ST_6ch_modes,
9317 		.need_dac_fix = 1,
9318 		.const_channel_count = 6,
9319 		.input_mux = &alc883_capture_source,
9320 		.unsol_event = alc_automute_amp_unsol_event,
9321 		.setup = alc888_acer_aspire_6530g_setup,
9322 		.init_hook = alc_automute_amp,
9323 	},
9324 	[ALC883_MEDION] = {
9325 		.mixers = { alc883_fivestack_mixer,
9326 			    alc883_chmode_mixer },
9327 		.init_verbs = { alc883_init_verbs,
9328 				alc883_medion_eapd_verbs },
9329 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9330 		.dac_nids = alc883_dac_nids,
9331 		.adc_nids = alc883_adc_nids_alt,
9332 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9333 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9334 		.channel_mode = alc883_sixstack_modes,
9335 		.input_mux = &alc883_capture_source,
9336 	},
9337 	[ALC883_MEDION_MD2] = {
9338 		.mixers = { alc883_medion_md2_mixer},
9339 		.init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9340 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9341 		.dac_nids = alc883_dac_nids,
9342 		.dig_out_nid = ALC883_DIGOUT_NID,
9343 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9344 		.channel_mode = alc883_3ST_2ch_modes,
9345 		.input_mux = &alc883_capture_source,
9346 		.unsol_event = alc_automute_amp_unsol_event,
9347 		.setup = alc883_medion_md2_setup,
9348 		.init_hook = alc_automute_amp,
9349 	},
9350 	[ALC883_LAPTOP_EAPD] = {
9351 		.mixers = { alc883_base_mixer },
9352 		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9353 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9354 		.dac_nids = alc883_dac_nids,
9355 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9356 		.channel_mode = alc883_3ST_2ch_modes,
9357 		.input_mux = &alc883_capture_source,
9358 	},
9359 	[ALC883_CLEVO_M540R] = {
9360 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9361 		.init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9362 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9363 		.dac_nids = alc883_dac_nids,
9364 		.dig_out_nid = ALC883_DIGOUT_NID,
9365 		.dig_in_nid = ALC883_DIGIN_NID,
9366 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9367 		.channel_mode = alc883_3ST_6ch_clevo_modes,
9368 		.need_dac_fix = 1,
9369 		.input_mux = &alc883_capture_source,
9370 		/* This machine has the hardware HP auto-muting, thus
9371 		 * we need no software mute via unsol event
9372 		 */
9373 	},
9374 	[ALC883_CLEVO_M720] = {
9375 		.mixers = { alc883_clevo_m720_mixer },
9376 		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9377 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9378 		.dac_nids = alc883_dac_nids,
9379 		.dig_out_nid = ALC883_DIGOUT_NID,
9380 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9381 		.channel_mode = alc883_3ST_2ch_modes,
9382 		.input_mux = &alc883_capture_source,
9383 		.unsol_event = alc883_clevo_m720_unsol_event,
9384 		.setup = alc883_clevo_m720_setup,
9385 		.init_hook = alc883_clevo_m720_init_hook,
9386 	},
9387 	[ALC883_LENOVO_101E_2ch] = {
9388 		.mixers = { alc883_lenovo_101e_2ch_mixer},
9389 		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9390 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9391 		.dac_nids = alc883_dac_nids,
9392 		.adc_nids = alc883_adc_nids_alt,
9393 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9394 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9395 		.channel_mode = alc883_3ST_2ch_modes,
9396 		.input_mux = &alc883_lenovo_101e_capture_source,
9397 		.unsol_event = alc883_lenovo_101e_unsol_event,
9398 		.init_hook = alc883_lenovo_101e_all_automute,
9399 	},
9400 	[ALC883_LENOVO_NB0763] = {
9401 		.mixers = { alc883_lenovo_nb0763_mixer },
9402 		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9403 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9404 		.dac_nids = alc883_dac_nids,
9405 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9406 		.channel_mode = alc883_3ST_2ch_modes,
9407 		.need_dac_fix = 1,
9408 		.input_mux = &alc883_lenovo_nb0763_capture_source,
9409 		.unsol_event = alc_automute_amp_unsol_event,
9410 		.setup = alc883_medion_md2_setup,
9411 		.init_hook = alc_automute_amp,
9412 	},
9413 	[ALC888_LENOVO_MS7195_DIG] = {
9414 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9415 		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9416 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9417 		.dac_nids = alc883_dac_nids,
9418 		.dig_out_nid = ALC883_DIGOUT_NID,
9419 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9420 		.channel_mode = alc883_3ST_6ch_modes,
9421 		.need_dac_fix = 1,
9422 		.input_mux = &alc883_capture_source,
9423 		.unsol_event = alc883_lenovo_ms7195_unsol_event,
9424 		.init_hook = alc888_lenovo_ms7195_front_automute,
9425 	},
9426 	[ALC883_HAIER_W66] = {
9427 		.mixers = { alc883_targa_2ch_mixer},
9428 		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9429 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9430 		.dac_nids = alc883_dac_nids,
9431 		.dig_out_nid = ALC883_DIGOUT_NID,
9432 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9433 		.channel_mode = alc883_3ST_2ch_modes,
9434 		.input_mux = &alc883_capture_source,
9435 		.unsol_event = alc_automute_amp_unsol_event,
9436 		.setup = alc883_haier_w66_setup,
9437 		.init_hook = alc_automute_amp,
9438 	},
9439 	[ALC888_3ST_HP] = {
9440 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9441 		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9442 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9443 		.dac_nids = alc883_dac_nids,
9444 		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9445 		.channel_mode = alc888_3st_hp_modes,
9446 		.need_dac_fix = 1,
9447 		.input_mux = &alc883_capture_source,
9448 		.unsol_event = alc_automute_amp_unsol_event,
9449 		.setup = alc888_3st_hp_setup,
9450 		.init_hook = alc_automute_amp,
9451 	},
9452 	[ALC888_6ST_DELL] = {
9453 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9454 		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9455 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9456 		.dac_nids = alc883_dac_nids,
9457 		.dig_out_nid = ALC883_DIGOUT_NID,
9458 		.dig_in_nid = ALC883_DIGIN_NID,
9459 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9460 		.channel_mode = alc883_sixstack_modes,
9461 		.input_mux = &alc883_capture_source,
9462 		.unsol_event = alc_automute_amp_unsol_event,
9463 		.setup = alc888_6st_dell_setup,
9464 		.init_hook = alc_automute_amp,
9465 	},
9466 	[ALC883_MITAC] = {
9467 		.mixers = { alc883_mitac_mixer },
9468 		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9469 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9470 		.dac_nids = alc883_dac_nids,
9471 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9472 		.channel_mode = alc883_3ST_2ch_modes,
9473 		.input_mux = &alc883_capture_source,
9474 		.unsol_event = alc_automute_amp_unsol_event,
9475 		.setup = alc883_mitac_setup,
9476 		.init_hook = alc_automute_amp,
9477 	},
9478 	[ALC883_FUJITSU_PI2515] = {
9479 		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9480 		.init_verbs = { alc883_init_verbs,
9481 				alc883_2ch_fujitsu_pi2515_verbs},
9482 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9483 		.dac_nids = alc883_dac_nids,
9484 		.dig_out_nid = ALC883_DIGOUT_NID,
9485 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9486 		.channel_mode = alc883_3ST_2ch_modes,
9487 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9488 		.unsol_event = alc_automute_amp_unsol_event,
9489 		.setup = alc883_2ch_fujitsu_pi2515_setup,
9490 		.init_hook = alc_automute_amp,
9491 	},
9492 	[ALC888_FUJITSU_XA3530] = {
9493 		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
9494 		.init_verbs = { alc883_init_verbs,
9495 			alc888_fujitsu_xa3530_verbs },
9496 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9497 		.dac_nids = alc883_dac_nids,
9498 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9499 		.adc_nids = alc883_adc_nids_rev,
9500 		.capsrc_nids = alc883_capsrc_nids_rev,
9501 		.dig_out_nid = ALC883_DIGOUT_NID,
9502 		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9503 		.channel_mode = alc888_4ST_8ch_intel_modes,
9504 		.num_mux_defs =
9505 			ARRAY_SIZE(alc888_2_capture_sources),
9506 		.input_mux = alc888_2_capture_sources,
9507 		.unsol_event = alc_automute_amp_unsol_event,
9508 		.setup = alc888_fujitsu_xa3530_setup,
9509 		.init_hook = alc_automute_amp,
9510 	},
9511 	[ALC888_LENOVO_SKY] = {
9512 		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9513 		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9514 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9515 		.dac_nids = alc883_dac_nids,
9516 		.dig_out_nid = ALC883_DIGOUT_NID,
9517 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9518 		.channel_mode = alc883_sixstack_modes,
9519 		.need_dac_fix = 1,
9520 		.input_mux = &alc883_lenovo_sky_capture_source,
9521 		.unsol_event = alc_automute_amp_unsol_event,
9522 		.setup = alc888_lenovo_sky_setup,
9523 		.init_hook = alc_automute_amp,
9524 	},
9525 	[ALC888_ASUS_M90V] = {
9526 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9527 		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9528 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9529 		.dac_nids = alc883_dac_nids,
9530 		.dig_out_nid = ALC883_DIGOUT_NID,
9531 		.dig_in_nid = ALC883_DIGIN_NID,
9532 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9533 		.channel_mode = alc883_3ST_6ch_modes,
9534 		.need_dac_fix = 1,
9535 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9536 		.unsol_event = alc_sku_unsol_event,
9537 		.setup = alc883_mode2_setup,
9538 		.init_hook = alc_inithook,
9539 	},
9540 	[ALC888_ASUS_EEE1601] = {
9541 		.mixers = { alc883_asus_eee1601_mixer },
9542 		.cap_mixer = alc883_asus_eee1601_cap_mixer,
9543 		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9544 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9545 		.dac_nids = alc883_dac_nids,
9546 		.dig_out_nid = ALC883_DIGOUT_NID,
9547 		.dig_in_nid = ALC883_DIGIN_NID,
9548 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9549 		.channel_mode = alc883_3ST_2ch_modes,
9550 		.need_dac_fix = 1,
9551 		.input_mux = &alc883_asus_eee1601_capture_source,
9552 		.unsol_event = alc_sku_unsol_event,
9553 		.init_hook = alc883_eee1601_inithook,
9554 	},
9555 	[ALC1200_ASUS_P5Q] = {
9556 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9557 		.init_verbs = { alc883_init_verbs },
9558 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9559 		.dac_nids = alc883_dac_nids,
9560 		.dig_out_nid = ALC1200_DIGOUT_NID,
9561 		.dig_in_nid = ALC883_DIGIN_NID,
9562 		.slave_dig_outs = alc1200_slave_dig_outs,
9563 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9564 		.channel_mode = alc883_sixstack_modes,
9565 		.input_mux = &alc883_capture_source,
9566 	},
9567 	[ALC889A_MB31] = {
9568 		.mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9569 		.init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9570 			alc880_gpio1_init_verbs },
9571 		.adc_nids = alc883_adc_nids,
9572 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9573 		.dac_nids = alc883_dac_nids,
9574 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9575 		.channel_mode = alc889A_mb31_6ch_modes,
9576 		.num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9577 		.input_mux = &alc889A_mb31_capture_source,
9578 		.dig_out_nid = ALC883_DIGOUT_NID,
9579 		.unsol_event = alc889A_mb31_unsol_event,
9580 		.init_hook = alc889A_mb31_automute,
9581 	},
9582 	[ALC883_SONY_VAIO_TT] = {
9583 		.mixers = { alc883_vaiott_mixer },
9584 		.init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9585 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9586 		.dac_nids = alc883_dac_nids,
9587 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9588 		.channel_mode = alc883_3ST_2ch_modes,
9589 		.input_mux = &alc883_capture_source,
9590 		.unsol_event = alc_automute_amp_unsol_event,
9591 		.setup = alc883_vaiott_setup,
9592 		.init_hook = alc_automute_amp,
9593 	},
9594 };
9595 
9596 
9597 /*
9598  * Pin config fixes
9599  */
9600 enum {
9601 	PINFIX_ABIT_AW9D_MAX
9602 };
9603 
9604 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9605 	{ 0x15, 0x01080104 }, /* side */
9606 	{ 0x16, 0x01011012 }, /* rear */
9607 	{ 0x17, 0x01016011 }, /* clfe */
9608 	{ }
9609 };
9610 
9611 static const struct alc_fixup alc882_fixups[] = {
9612 	[PINFIX_ABIT_AW9D_MAX] = {
9613 		.pins = alc882_abit_aw9d_pinfix
9614 	},
9615 };
9616 
9617 static struct snd_pci_quirk alc882_fixup_tbl[] = {
9618 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9619 	{}
9620 };
9621 
9622 /*
9623  * BIOS auto configuration
9624  */
9625 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
9626 						const struct auto_pin_cfg *cfg)
9627 {
9628 	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
9629 }
9630 
9631 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9632 					      hda_nid_t nid, int pin_type,
9633 					      int dac_idx)
9634 {
9635 	/* set as output */
9636 	struct alc_spec *spec = codec->spec;
9637 	int idx;
9638 
9639 	alc_set_pin_output(codec, nid, pin_type);
9640 	if (spec->multiout.dac_nids[dac_idx] == 0x25)
9641 		idx = 4;
9642 	else
9643 		idx = spec->multiout.dac_nids[dac_idx] - 2;
9644 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9645 
9646 }
9647 
9648 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9649 {
9650 	struct alc_spec *spec = codec->spec;
9651 	int i;
9652 
9653 	for (i = 0; i <= HDA_SIDE; i++) {
9654 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
9655 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
9656 		if (nid)
9657 			alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9658 							  i);
9659 	}
9660 }
9661 
9662 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9663 {
9664 	struct alc_spec *spec = codec->spec;
9665 	hda_nid_t pin;
9666 
9667 	pin = spec->autocfg.hp_pins[0];
9668 	if (pin) /* connect to front */
9669 		/* use dac 0 */
9670 		alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9671 	pin = spec->autocfg.speaker_pins[0];
9672 	if (pin)
9673 		alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9674 }
9675 
9676 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9677 {
9678 	struct alc_spec *spec = codec->spec;
9679 	int i;
9680 
9681 	for (i = 0; i < AUTO_PIN_LAST; i++) {
9682 		hda_nid_t nid = spec->autocfg.input_pins[i];
9683 		if (!nid)
9684 			continue;
9685 		alc_set_input_pin(codec, nid, i);
9686 		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9687 			snd_hda_codec_write(codec, nid, 0,
9688 					    AC_VERB_SET_AMP_GAIN_MUTE,
9689 					    AMP_OUT_MUTE);
9690 	}
9691 }
9692 
9693 static void alc882_auto_init_input_src(struct hda_codec *codec)
9694 {
9695 	struct alc_spec *spec = codec->spec;
9696 	int c;
9697 
9698 	for (c = 0; c < spec->num_adc_nids; c++) {
9699 		hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9700 		hda_nid_t nid = spec->capsrc_nids[c];
9701 		unsigned int mux_idx;
9702 		const struct hda_input_mux *imux;
9703 		int conns, mute, idx, item;
9704 
9705 		conns = snd_hda_get_connections(codec, nid, conn_list,
9706 						ARRAY_SIZE(conn_list));
9707 		if (conns < 0)
9708 			continue;
9709 		mux_idx = c >= spec->num_mux_defs ? 0 : c;
9710 		imux = &spec->input_mux[mux_idx];
9711 		for (idx = 0; idx < conns; idx++) {
9712 			/* if the current connection is the selected one,
9713 			 * unmute it as default - otherwise mute it
9714 			 */
9715 			mute = AMP_IN_MUTE(idx);
9716 			for (item = 0; item < imux->num_items; item++) {
9717 				if (imux->items[item].index == idx) {
9718 					if (spec->cur_mux[c] == item)
9719 						mute = AMP_IN_UNMUTE(idx);
9720 					break;
9721 				}
9722 			}
9723 			/* check if we have a selector or mixer
9724 			 * we could check for the widget type instead, but
9725 			 * just check for Amp-In presence (in case of mixer
9726 			 * without amp-in there is something wrong, this
9727 			 * function shouldn't be used or capsrc nid is wrong)
9728 			 */
9729 			if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9730 				snd_hda_codec_write(codec, nid, 0,
9731 						    AC_VERB_SET_AMP_GAIN_MUTE,
9732 						    mute);
9733 			else if (mute != AMP_IN_MUTE(idx))
9734 				snd_hda_codec_write(codec, nid, 0,
9735 						    AC_VERB_SET_CONNECT_SEL,
9736 						    idx);
9737 		}
9738 	}
9739 }
9740 
9741 /* add mic boosts if needed */
9742 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9743 {
9744 	struct alc_spec *spec = codec->spec;
9745 	int err;
9746 	hda_nid_t nid;
9747 
9748 	nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9749 	if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9750 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
9751 				  "Mic Boost",
9752 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9753 		if (err < 0)
9754 			return err;
9755 	}
9756 	nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9757 	if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9758 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
9759 				  "Front Mic Boost",
9760 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9761 		if (err < 0)
9762 			return err;
9763 	}
9764 	return 0;
9765 }
9766 
9767 /* almost identical with ALC880 parser... */
9768 static int alc882_parse_auto_config(struct hda_codec *codec)
9769 {
9770 	struct alc_spec *spec = codec->spec;
9771 	static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
9772 	int i, err;
9773 
9774 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9775 					   alc882_ignore);
9776 	if (err < 0)
9777 		return err;
9778 	if (!spec->autocfg.line_outs)
9779 		return 0; /* can't find valid BIOS pin config */
9780 
9781 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
9782 	if (err < 0)
9783 		return err;
9784 	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
9785 	if (err < 0)
9786 		return err;
9787 	err = alc880_auto_create_extra_out(spec,
9788 					   spec->autocfg.speaker_pins[0],
9789 					   "Speaker");
9790 	if (err < 0)
9791 		return err;
9792 	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
9793 					   "Headphone");
9794 	if (err < 0)
9795 		return err;
9796 	err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
9797 	if (err < 0)
9798 		return err;
9799 
9800 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9801 
9802 	/* check multiple SPDIF-out (for recent codecs) */
9803 	for (i = 0; i < spec->autocfg.dig_outs; i++) {
9804 		hda_nid_t dig_nid;
9805 		err = snd_hda_get_connections(codec,
9806 					      spec->autocfg.dig_out_pins[i],
9807 					      &dig_nid, 1);
9808 		if (err < 0)
9809 			continue;
9810 		if (!i)
9811 			spec->multiout.dig_out_nid = dig_nid;
9812 		else {
9813 			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
9814 			spec->slave_dig_outs[i - 1] = dig_nid;
9815 			if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
9816 				break;
9817 		}
9818 	}
9819 	if (spec->autocfg.dig_in_pin)
9820 		spec->dig_in_nid = ALC880_DIGIN_NID;
9821 
9822 	if (spec->kctls.list)
9823 		add_mixer(spec, spec->kctls.list);
9824 
9825 	add_verb(spec, alc883_auto_init_verbs);
9826 	/* if ADC 0x07 is available, initialize it, too */
9827 	if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
9828 		add_verb(spec, alc882_adc1_init_verbs);
9829 
9830 	spec->num_mux_defs = 1;
9831 	spec->input_mux = &spec->private_imux[0];
9832 
9833 	alc_ssid_check(codec, 0x15, 0x1b, 0x14);
9834 
9835 	err = alc_auto_add_mic_boost(codec);
9836 	if (err < 0)
9837 		return err;
9838 
9839 	return 1; /* config found */
9840 }
9841 
9842 /* additional initialization for auto-configuration model */
9843 static void alc882_auto_init(struct hda_codec *codec)
9844 {
9845 	struct alc_spec *spec = codec->spec;
9846 	alc882_auto_init_multi_out(codec);
9847 	alc882_auto_init_hp_out(codec);
9848 	alc882_auto_init_analog_input(codec);
9849 	alc882_auto_init_input_src(codec);
9850 	if (spec->unsol_event)
9851 		alc_inithook(codec);
9852 }
9853 
9854 static int patch_alc882(struct hda_codec *codec)
9855 {
9856 	struct alc_spec *spec;
9857 	int err, board_config;
9858 
9859 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9860 	if (spec == NULL)
9861 		return -ENOMEM;
9862 
9863 	codec->spec = spec;
9864 
9865 	switch (codec->vendor_id) {
9866 	case 0x10ec0882:
9867 	case 0x10ec0885:
9868 		break;
9869 	default:
9870 		/* ALC883 and variants */
9871 		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9872 		break;
9873 	}
9874 
9875 	board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
9876 						  alc882_models,
9877 						  alc882_cfg_tbl);
9878 
9879 	if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
9880 		board_config = snd_hda_check_board_codec_sid_config(codec,
9881 			ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
9882 
9883 	if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
9884 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
9885 		       codec->chip_name);
9886 		board_config = ALC882_AUTO;
9887 	}
9888 
9889 	alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
9890 
9891 	if (board_config == ALC882_AUTO) {
9892 		/* automatic parse from the BIOS config */
9893 		err = alc882_parse_auto_config(codec);
9894 		if (err < 0) {
9895 			alc_free(codec);
9896 			return err;
9897 		} else if (!err) {
9898 			printk(KERN_INFO
9899 			       "hda_codec: Cannot set up configuration "
9900 			       "from BIOS.  Using base mode...\n");
9901 			board_config = ALC882_3ST_DIG;
9902 		}
9903 	}
9904 
9905 	err = snd_hda_attach_beep_device(codec, 0x1);
9906 	if (err < 0) {
9907 		alc_free(codec);
9908 		return err;
9909 	}
9910 
9911 	if (board_config != ALC882_AUTO)
9912 		setup_preset(codec, &alc882_presets[board_config]);
9913 
9914 	spec->stream_analog_playback = &alc882_pcm_analog_playback;
9915 	spec->stream_analog_capture = &alc882_pcm_analog_capture;
9916 	/* FIXME: setup DAC5 */
9917 	/*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
9918 	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
9919 
9920 	spec->stream_digital_playback = &alc882_pcm_digital_playback;
9921 	spec->stream_digital_capture = &alc882_pcm_digital_capture;
9922 
9923 	if (codec->vendor_id == 0x10ec0888)
9924 		spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9925 
9926 	if (!spec->adc_nids && spec->input_mux) {
9927 		int i;
9928 		spec->num_adc_nids = 0;
9929 		for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
9930 			hda_nid_t cap;
9931 			hda_nid_t nid = alc882_adc_nids[i];
9932 			unsigned int wcap = get_wcaps(codec, nid);
9933 			/* get type */
9934 			wcap = get_wcaps_type(wcap);
9935 			if (wcap != AC_WID_AUD_IN)
9936 				continue;
9937 			spec->private_adc_nids[spec->num_adc_nids] = nid;
9938 			err = snd_hda_get_connections(codec, nid, &cap, 1);
9939 			if (err < 0)
9940 				continue;
9941 			spec->private_capsrc_nids[spec->num_adc_nids] = cap;
9942 			spec->num_adc_nids++;
9943 		}
9944 		spec->adc_nids = spec->private_adc_nids;
9945 		spec->capsrc_nids = spec->private_capsrc_nids;
9946 	}
9947 
9948 	set_capture_mixer(codec);
9949 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9950 
9951 	spec->vmaster_nid = 0x0c;
9952 
9953 	codec->patch_ops = alc_patch_ops;
9954 	if (board_config == ALC882_AUTO)
9955 		spec->init_hook = alc882_auto_init;
9956 #ifdef CONFIG_SND_HDA_POWER_SAVE
9957 	if (!spec->loopback.amplist)
9958 		spec->loopback.amplist = alc882_loopbacks;
9959 #endif
9960 	codec->proc_widget_hook = print_realtek_coef;
9961 
9962 	return 0;
9963 }
9964 
9965 
9966 /*
9967  * ALC262 support
9968  */
9969 
9970 #define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
9971 #define ALC262_DIGIN_NID	ALC880_DIGIN_NID
9972 
9973 #define alc262_dac_nids		alc260_dac_nids
9974 #define alc262_adc_nids		alc882_adc_nids
9975 #define alc262_adc_nids_alt	alc882_adc_nids_alt
9976 #define alc262_capsrc_nids	alc882_capsrc_nids
9977 #define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
9978 
9979 #define alc262_modes		alc260_modes
9980 #define alc262_capture_source	alc882_capture_source
9981 
9982 static hda_nid_t alc262_dmic_adc_nids[1] = {
9983 	/* ADC0 */
9984 	0x09
9985 };
9986 
9987 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9988 
9989 static struct snd_kcontrol_new alc262_base_mixer[] = {
9990 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9991 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9992 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9993 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9994 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9995 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9996 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9997 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9998 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9999 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10000 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10001 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10002 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10003 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10004 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10005 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10006 	{ } /* end */
10007 };
10008 
10009 /* update HP, line and mono-out pins according to the master switch */
10010 static void alc262_hp_master_update(struct hda_codec *codec)
10011 {
10012 	struct alc_spec *spec = codec->spec;
10013 	int val = spec->master_sw;
10014 
10015 	/* HP & line-out */
10016 	snd_hda_codec_write_cache(codec, 0x1b, 0,
10017 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10018 				  val ? PIN_HP : 0);
10019 	snd_hda_codec_write_cache(codec, 0x15, 0,
10020 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10021 				  val ? PIN_HP : 0);
10022 	/* mono (speaker) depending on the HP jack sense */
10023 	val = val && !spec->jack_present;
10024 	snd_hda_codec_write_cache(codec, 0x16, 0,
10025 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10026 				  val ? PIN_OUT : 0);
10027 }
10028 
10029 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10030 {
10031 	struct alc_spec *spec = codec->spec;
10032 	unsigned int presence;
10033 	presence = snd_hda_codec_read(codec, 0x1b, 0,
10034 				      AC_VERB_GET_PIN_SENSE, 0);
10035 	spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
10036 	alc262_hp_master_update(codec);
10037 }
10038 
10039 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10040 {
10041 	if ((res >> 26) != ALC880_HP_EVENT)
10042 		return;
10043 	alc262_hp_bpc_automute(codec);
10044 }
10045 
10046 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10047 {
10048 	struct alc_spec *spec = codec->spec;
10049 	unsigned int presence;
10050 	presence = snd_hda_codec_read(codec, 0x15, 0,
10051 				      AC_VERB_GET_PIN_SENSE, 0);
10052 	spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
10053 	alc262_hp_master_update(codec);
10054 }
10055 
10056 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10057 					   unsigned int res)
10058 {
10059 	if ((res >> 26) != ALC880_HP_EVENT)
10060 		return;
10061 	alc262_hp_wildwest_automute(codec);
10062 }
10063 
10064 #define alc262_hp_master_sw_get		alc260_hp_master_sw_get
10065 
10066 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10067 				   struct snd_ctl_elem_value *ucontrol)
10068 {
10069 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10070 	struct alc_spec *spec = codec->spec;
10071 	int val = !!*ucontrol->value.integer.value;
10072 
10073 	if (val == spec->master_sw)
10074 		return 0;
10075 	spec->master_sw = val;
10076 	alc262_hp_master_update(codec);
10077 	return 1;
10078 }
10079 
10080 #define ALC262_HP_MASTER_SWITCH					\
10081 	{							\
10082 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
10083 		.name = "Master Playback Switch",		\
10084 		.info = snd_ctl_boolean_mono_info,		\
10085 		.get = alc262_hp_master_sw_get,			\
10086 		.put = alc262_hp_master_sw_put,			\
10087 	}
10088 
10089 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10090 	ALC262_HP_MASTER_SWITCH,
10091 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10092 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10093 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10094 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10095 			      HDA_OUTPUT),
10096 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10097 			    HDA_OUTPUT),
10098 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10099 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10100 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10101 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10102 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10103 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10104 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10105 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10106 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10107 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10108 	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10109 	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10110 	{ } /* end */
10111 };
10112 
10113 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10114 	ALC262_HP_MASTER_SWITCH,
10115 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10116 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10117 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10118 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10119 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10120 			      HDA_OUTPUT),
10121 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10122 			    HDA_OUTPUT),
10123 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10124 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10125 	HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10126 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10127 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10128 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10129 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10130 	{ } /* end */
10131 };
10132 
10133 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10134 	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10135 	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10136 	HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10137 	{ } /* end */
10138 };
10139 
10140 /* mute/unmute internal speaker according to the hp jack and mute state */
10141 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10142 {
10143 	struct alc_spec *spec = codec->spec;
10144 
10145 	spec->autocfg.hp_pins[0] = 0x15;
10146 	spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
10147 }
10148 
10149 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10150 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10151 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10152 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10153 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10154 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10155 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10156 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10157 	{ } /* end */
10158 };
10159 
10160 static struct hda_verb alc262_hp_t5735_verbs[] = {
10161 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10162 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10163 
10164 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10165 	{ }
10166 };
10167 
10168 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10169 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10170 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10171 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10172 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10173 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10174 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10175 	{ } /* end */
10176 };
10177 
10178 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10179 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10180 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10181 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10182 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10183 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10184 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10185 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10186 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10187 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10188 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10189 	{}
10190 };
10191 
10192 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10193 	.num_items = 1,
10194 	.items = {
10195 		{ "Line", 0x1 },
10196 	},
10197 };
10198 
10199 /* bind hp and internal speaker mute (with plug check) as master switch */
10200 static void alc262_hippo_master_update(struct hda_codec *codec)
10201 {
10202 	struct alc_spec *spec = codec->spec;
10203 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10204 	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10205 	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10206 	unsigned int mute;
10207 
10208 	/* HP */
10209 	mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10210 	snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10211 				 HDA_AMP_MUTE, mute);
10212 	/* mute internal speaker per jack sense */
10213 	if (spec->jack_present)
10214 		mute = HDA_AMP_MUTE;
10215 	if (line_nid)
10216 		snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10217 					 HDA_AMP_MUTE, mute);
10218 	if (speaker_nid && speaker_nid != line_nid)
10219 		snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10220 					 HDA_AMP_MUTE, mute);
10221 }
10222 
10223 #define alc262_hippo_master_sw_get	alc262_hp_master_sw_get
10224 
10225 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10226 				      struct snd_ctl_elem_value *ucontrol)
10227 {
10228 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10229 	struct alc_spec *spec = codec->spec;
10230 	int val = !!*ucontrol->value.integer.value;
10231 
10232 	if (val == spec->master_sw)
10233 		return 0;
10234 	spec->master_sw = val;
10235 	alc262_hippo_master_update(codec);
10236 	return 1;
10237 }
10238 
10239 #define ALC262_HIPPO_MASTER_SWITCH				\
10240 	{							\
10241 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
10242 		.name = "Master Playback Switch",		\
10243 		.info = snd_ctl_boolean_mono_info,		\
10244 		.get = alc262_hippo_master_sw_get,		\
10245 		.put = alc262_hippo_master_sw_put,		\
10246 	}
10247 
10248 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10249 	ALC262_HIPPO_MASTER_SWITCH,
10250 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10251 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10252 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10253 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10254 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10255 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10256 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10257 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10258 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10259 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10260 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10261 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10262 	{ } /* end */
10263 };
10264 
10265 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10266 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10267 	ALC262_HIPPO_MASTER_SWITCH,
10268 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10269 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10270 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10271 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10272 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10273 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10274 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10275 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10276 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10277 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10278 	{ } /* end */
10279 };
10280 
10281 /* mute/unmute internal speaker according to the hp jack and mute state */
10282 static void alc262_hippo_automute(struct hda_codec *codec)
10283 {
10284 	struct alc_spec *spec = codec->spec;
10285 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10286 	unsigned int present;
10287 
10288 	/* need to execute and sync at first */
10289 	snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
10290 	present = snd_hda_codec_read(codec, hp_nid, 0,
10291 				     AC_VERB_GET_PIN_SENSE, 0);
10292 	spec->jack_present = (present & 0x80000000) != 0;
10293 	alc262_hippo_master_update(codec);
10294 }
10295 
10296 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10297 {
10298 	if ((res >> 26) != ALC880_HP_EVENT)
10299 		return;
10300 	alc262_hippo_automute(codec);
10301 }
10302 
10303 static void alc262_hippo_setup(struct hda_codec *codec)
10304 {
10305 	struct alc_spec *spec = codec->spec;
10306 
10307 	spec->autocfg.hp_pins[0] = 0x15;
10308 	spec->autocfg.speaker_pins[0] = 0x14;
10309 }
10310 
10311 static void alc262_hippo1_setup(struct hda_codec *codec)
10312 {
10313 	struct alc_spec *spec = codec->spec;
10314 
10315 	spec->autocfg.hp_pins[0] = 0x1b;
10316 	spec->autocfg.speaker_pins[0] = 0x14;
10317 }
10318 
10319 
10320 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10321 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10322 	ALC262_HIPPO_MASTER_SWITCH,
10323 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10324 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10325 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10326 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10327 	{ } /* end */
10328 };
10329 
10330 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10331 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10332 	ALC262_HIPPO_MASTER_SWITCH,
10333 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10334 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10335 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10336 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10337 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10338 	{ } /* end */
10339 };
10340 
10341 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10342 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10343 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10344 	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10345 	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10346 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10347 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10348 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10349 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10350 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10351 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10352 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10353 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10354 	{ } /* end */
10355 };
10356 
10357 static struct hda_verb alc262_tyan_verbs[] = {
10358 	/* Headphone automute */
10359 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10360 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10361 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10362 
10363 	/* P11 AUX_IN, white 4-pin connector */
10364 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10365 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10366 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10367 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10368 
10369 	{}
10370 };
10371 
10372 /* unsolicited event for HP jack sensing */
10373 static void alc262_tyan_setup(struct hda_codec *codec)
10374 {
10375 	struct alc_spec *spec = codec->spec;
10376 
10377 	spec->autocfg.hp_pins[0] = 0x1b;
10378 	spec->autocfg.speaker_pins[0] = 0x15;
10379 }
10380 
10381 
10382 #define alc262_capture_mixer		alc882_capture_mixer
10383 #define alc262_capture_alt_mixer	alc882_capture_alt_mixer
10384 
10385 /*
10386  * generic initialization of ADC, input mixers and output mixers
10387  */
10388 static struct hda_verb alc262_init_verbs[] = {
10389 	/*
10390 	 * Unmute ADC0-2 and set the default input to mic-in
10391 	 */
10392 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10393 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10394 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10395 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10396 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10397 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10398 
10399 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10400 	 * mixer widget
10401 	 * Note: PASD motherboards uses the Line In 2 as the input for
10402 	 * front panel mic (mic 2)
10403 	 */
10404 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10405 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10406 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10407 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10408 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10409 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10410 
10411 	/*
10412 	 * Set up output mixers (0x0c - 0x0e)
10413 	 */
10414 	/* set vol=0 to output mixers */
10415 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10416 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10417 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10418 	/* set up input amps for analog loopback */
10419 	/* Amp Indices: DAC = 0, mixer = 1 */
10420 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10421 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10422 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10423 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10424 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10425 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10426 
10427 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10428 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10429 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10430 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10431 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10432 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10433 
10434 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10435 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10436 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10437 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10438 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10439 
10440 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10441 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10442 
10443 	/* FIXME: use matrix-type input source selection */
10444 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10445 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10446 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10447 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10448 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10449 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10450 	/* Input mixer2 */
10451 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10452 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10453 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10454 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10455 	/* Input mixer3 */
10456 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10457 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10458 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10459 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10460 
10461 	{ }
10462 };
10463 
10464 static struct hda_verb alc262_eapd_verbs[] = {
10465 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10466 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10467 	{ }
10468 };
10469 
10470 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10471 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10472 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10473 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10474 
10475 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10476 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10477 	{}
10478 };
10479 
10480 static struct hda_verb alc262_sony_unsol_verbs[] = {
10481 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10482 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10483 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
10484 
10485 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10486 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10487 	{}
10488 };
10489 
10490 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10491 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10492 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10493 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10494 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10495 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10496 	{ } /* end */
10497 };
10498 
10499 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10500 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10501 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10502 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10503 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10504 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10505 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10506 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10507 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10508 	{}
10509 };
10510 
10511 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10512 {
10513 	struct alc_spec *spec = codec->spec;
10514 
10515 	spec->autocfg.hp_pins[0] = 0x15;
10516 	spec->autocfg.speaker_pins[0] = 0x14;
10517 	spec->ext_mic.pin = 0x18;
10518 	spec->ext_mic.mux_idx = 0;
10519 	spec->int_mic.pin = 0x12;
10520 	spec->int_mic.mux_idx = 9;
10521 	spec->auto_mic = 1;
10522 }
10523 
10524 /*
10525  * nec model
10526  *  0x15 = headphone
10527  *  0x16 = internal speaker
10528  *  0x18 = external mic
10529  */
10530 
10531 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10532 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10533 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10534 
10535 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10536 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10537 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10538 
10539 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10540 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10541 	{ } /* end */
10542 };
10543 
10544 static struct hda_verb alc262_nec_verbs[] = {
10545 	/* Unmute Speaker */
10546 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10547 
10548 	/* Headphone */
10549 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10550 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10551 
10552 	/* External mic to headphone */
10553 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10554 	/* External mic to speaker */
10555 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10556 	{}
10557 };
10558 
10559 /*
10560  * fujitsu model
10561  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10562  *  0x1b = port replicator headphone out
10563  */
10564 
10565 #define ALC_HP_EVENT	0x37
10566 
10567 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10568 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10569 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10570 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10571 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10572 	{}
10573 };
10574 
10575 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10576 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10577 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10578 	{}
10579 };
10580 
10581 static struct hda_input_mux alc262_fujitsu_capture_source = {
10582 	.num_items = 3,
10583 	.items = {
10584 		{ "Mic", 0x0 },
10585 		{ "Int Mic", 0x1 },
10586 		{ "CD", 0x4 },
10587 	},
10588 };
10589 
10590 static struct hda_input_mux alc262_HP_capture_source = {
10591 	.num_items = 5,
10592 	.items = {
10593 		{ "Mic", 0x0 },
10594 		{ "Front Mic", 0x1 },
10595 		{ "Line", 0x2 },
10596 		{ "CD", 0x4 },
10597 		{ "AUX IN", 0x6 },
10598 	},
10599 };
10600 
10601 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10602 	.num_items = 4,
10603 	.items = {
10604 		{ "Mic", 0x0 },
10605 		{ "Front Mic", 0x2 },
10606 		{ "Line", 0x1 },
10607 		{ "CD", 0x4 },
10608 	},
10609 };
10610 
10611 /* mute/unmute internal speaker according to the hp jacks and mute state */
10612 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10613 {
10614 	struct alc_spec *spec = codec->spec;
10615 	unsigned int mute;
10616 
10617 	if (force || !spec->sense_updated) {
10618 		unsigned int present;
10619 		/* need to execute and sync at first */
10620 		snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10621 		/* check laptop HP jack */
10622 		present = snd_hda_codec_read(codec, 0x14, 0,
10623 					     AC_VERB_GET_PIN_SENSE, 0);
10624 		/* need to execute and sync at first */
10625 		snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10626 		/* check docking HP jack */
10627 		present |= snd_hda_codec_read(codec, 0x1b, 0,
10628 					      AC_VERB_GET_PIN_SENSE, 0);
10629 		if (present & AC_PINSENSE_PRESENCE)
10630 			spec->jack_present = 1;
10631 		else
10632 			spec->jack_present = 0;
10633 		spec->sense_updated = 1;
10634 	}
10635 	/* unmute internal speaker only if both HPs are unplugged and
10636 	 * master switch is on
10637 	 */
10638 	if (spec->jack_present)
10639 		mute = HDA_AMP_MUTE;
10640 	else
10641 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10642 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10643 				 HDA_AMP_MUTE, mute);
10644 }
10645 
10646 /* unsolicited event for HP jack sensing */
10647 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10648 				       unsigned int res)
10649 {
10650 	if ((res >> 26) != ALC_HP_EVENT)
10651 		return;
10652 	alc262_fujitsu_automute(codec, 1);
10653 }
10654 
10655 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10656 {
10657 	alc262_fujitsu_automute(codec, 1);
10658 }
10659 
10660 /* bind volumes of both NID 0x0c and 0x0d */
10661 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10662 	.ops = &snd_hda_bind_vol,
10663 	.values = {
10664 		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10665 		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10666 		0
10667 	},
10668 };
10669 
10670 /* mute/unmute internal speaker according to the hp jack and mute state */
10671 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10672 {
10673 	struct alc_spec *spec = codec->spec;
10674 	unsigned int mute;
10675 
10676 	if (force || !spec->sense_updated) {
10677 		unsigned int present_int_hp;
10678 		/* need to execute and sync at first */
10679 		snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10680 		present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10681 					AC_VERB_GET_PIN_SENSE, 0);
10682 		spec->jack_present = (present_int_hp & 0x80000000) != 0;
10683 		spec->sense_updated = 1;
10684 	}
10685 	if (spec->jack_present) {
10686 		/* mute internal speaker */
10687 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10688 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
10689 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10690 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
10691 	} else {
10692 		/* unmute internal speaker if necessary */
10693 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10694 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10695 					 HDA_AMP_MUTE, mute);
10696 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10697 					 HDA_AMP_MUTE, mute);
10698 	}
10699 }
10700 
10701 /* unsolicited event for HP jack sensing */
10702 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10703 				       unsigned int res)
10704 {
10705 	if ((res >> 26) != ALC_HP_EVENT)
10706 		return;
10707 	alc262_lenovo_3000_automute(codec, 1);
10708 }
10709 
10710 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10711 				  int dir, int idx, long *valp)
10712 {
10713 	int i, change = 0;
10714 
10715 	for (i = 0; i < 2; i++, valp++)
10716 		change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10717 						   HDA_AMP_MUTE,
10718 						   *valp ? 0 : HDA_AMP_MUTE);
10719 	return change;
10720 }
10721 
10722 /* bind hp and internal speaker mute (with plug check) */
10723 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10724 					 struct snd_ctl_elem_value *ucontrol)
10725 {
10726 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10727 	long *valp = ucontrol->value.integer.value;
10728 	int change;
10729 
10730 	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10731 	change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10732 	if (change)
10733 		alc262_fujitsu_automute(codec, 0);
10734 	return change;
10735 }
10736 
10737 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10738 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10739 	{
10740 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10741 		.name = "Master Playback Switch",
10742 		.info = snd_hda_mixer_amp_switch_info,
10743 		.get = snd_hda_mixer_amp_switch_get,
10744 		.put = alc262_fujitsu_master_sw_put,
10745 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10746 	},
10747 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10748 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10749 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10750 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10751 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10752 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10753 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10754 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10755 	{ } /* end */
10756 };
10757 
10758 /* bind hp and internal speaker mute (with plug check) */
10759 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10760 					 struct snd_ctl_elem_value *ucontrol)
10761 {
10762 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10763 	long *valp = ucontrol->value.integer.value;
10764 	int change;
10765 
10766 	change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10767 	if (change)
10768 		alc262_lenovo_3000_automute(codec, 0);
10769 	return change;
10770 }
10771 
10772 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10773 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10774 	{
10775 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10776 		.name = "Master Playback Switch",
10777 		.info = snd_hda_mixer_amp_switch_info,
10778 		.get = snd_hda_mixer_amp_switch_get,
10779 		.put = alc262_lenovo_3000_master_sw_put,
10780 		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10781 	},
10782 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10783 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10784 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10785 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10786 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10787 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10788 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10789 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10790 	{ } /* end */
10791 };
10792 
10793 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10794 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10795 	ALC262_HIPPO_MASTER_SWITCH,
10796 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10797 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10798 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10799 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10800 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10801 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10802 	{ } /* end */
10803 };
10804 
10805 /* additional init verbs for Benq laptops */
10806 static struct hda_verb alc262_EAPD_verbs[] = {
10807 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10808 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10809 	{}
10810 };
10811 
10812 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10813 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10814 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10815 
10816 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10817 	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10818 	{}
10819 };
10820 
10821 /* Samsung Q1 Ultra Vista model setup */
10822 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10823 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10824 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10825 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10826 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10827 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10828 	HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10829 	{ } /* end */
10830 };
10831 
10832 static struct hda_verb alc262_ultra_verbs[] = {
10833 	/* output mixer */
10834 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10835 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10836 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10837 	/* speaker */
10838 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10839 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10840 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10841 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10842 	/* HP */
10843 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10844 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10845 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10846 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10847 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10848 	/* internal mic */
10849 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10850 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10851 	/* ADC, choose mic */
10852 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10853 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10854 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10855 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10856 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10857 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10858 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10859 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10860 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10861 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10862 	{}
10863 };
10864 
10865 /* mute/unmute internal speaker according to the hp jack and mute state */
10866 static void alc262_ultra_automute(struct hda_codec *codec)
10867 {
10868 	struct alc_spec *spec = codec->spec;
10869 	unsigned int mute;
10870 
10871 	mute = 0;
10872 	/* auto-mute only when HP is used as HP */
10873 	if (!spec->cur_mux[0]) {
10874 		unsigned int present;
10875 		/* need to execute and sync at first */
10876 		snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10877 		present = snd_hda_codec_read(codec, 0x15, 0,
10878 					     AC_VERB_GET_PIN_SENSE, 0);
10879 		spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10880 		if (spec->jack_present)
10881 			mute = HDA_AMP_MUTE;
10882 	}
10883 	/* mute/unmute internal speaker */
10884 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10885 				 HDA_AMP_MUTE, mute);
10886 	/* mute/unmute HP */
10887 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10888 				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10889 }
10890 
10891 /* unsolicited event for HP jack sensing */
10892 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10893 				       unsigned int res)
10894 {
10895 	if ((res >> 26) != ALC880_HP_EVENT)
10896 		return;
10897 	alc262_ultra_automute(codec);
10898 }
10899 
10900 static struct hda_input_mux alc262_ultra_capture_source = {
10901 	.num_items = 2,
10902 	.items = {
10903 		{ "Mic", 0x1 },
10904 		{ "Headphone", 0x7 },
10905 	},
10906 };
10907 
10908 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10909 				     struct snd_ctl_elem_value *ucontrol)
10910 {
10911 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10912 	struct alc_spec *spec = codec->spec;
10913 	int ret;
10914 
10915 	ret = alc_mux_enum_put(kcontrol, ucontrol);
10916 	if (!ret)
10917 		return 0;
10918 	/* reprogram the HP pin as mic or HP according to the input source */
10919 	snd_hda_codec_write_cache(codec, 0x15, 0,
10920 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10921 				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10922 	alc262_ultra_automute(codec); /* mute/unmute HP */
10923 	return ret;
10924 }
10925 
10926 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10927 	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10928 	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10929 	{
10930 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10931 		.name = "Capture Source",
10932 		.info = alc_mux_enum_info,
10933 		.get = alc_mux_enum_get,
10934 		.put = alc262_ultra_mux_enum_put,
10935 	},
10936 	{ } /* end */
10937 };
10938 
10939 /* We use two mixers depending on the output pin; 0x16 is a mono output
10940  * and thus it's bound with a different mixer.
10941  * This function returns which mixer amp should be used.
10942  */
10943 static int alc262_check_volbit(hda_nid_t nid)
10944 {
10945 	if (!nid)
10946 		return 0;
10947 	else if (nid == 0x16)
10948 		return 2;
10949 	else
10950 		return 1;
10951 }
10952 
10953 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
10954 				  const char *pfx, int *vbits)
10955 {
10956 	char name[32];
10957 	unsigned long val;
10958 	int vbit;
10959 
10960 	vbit = alc262_check_volbit(nid);
10961 	if (!vbit)
10962 		return 0;
10963 	if (*vbits & vbit) /* a volume control for this mixer already there */
10964 		return 0;
10965 	*vbits |= vbit;
10966 	snprintf(name, sizeof(name), "%s Playback Volume", pfx);
10967 	if (vbit == 2)
10968 		val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
10969 	else
10970 		val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
10971 	return add_control(spec, ALC_CTL_WIDGET_VOL, name, val);
10972 }
10973 
10974 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
10975 				 const char *pfx)
10976 {
10977 	char name[32];
10978 	unsigned long val;
10979 
10980 	if (!nid)
10981 		return 0;
10982 	snprintf(name, sizeof(name), "%s Playback Switch", pfx);
10983 	if (nid == 0x16)
10984 		val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
10985 	else
10986 		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
10987 	return add_control(spec, ALC_CTL_WIDGET_MUTE, name, val);
10988 }
10989 
10990 /* add playback controls from the parsed DAC table */
10991 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10992 					     const struct auto_pin_cfg *cfg)
10993 {
10994 	const char *pfx;
10995 	int vbits;
10996 	int err;
10997 
10998 	spec->multiout.num_dacs = 1;	/* only use one dac */
10999 	spec->multiout.dac_nids = spec->private_dac_nids;
11000 	spec->multiout.dac_nids[0] = 2;
11001 
11002 	if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11003 		pfx = "Master";
11004 	else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11005 		pfx = "Speaker";
11006 	else
11007 		pfx = "Front";
11008 	err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11009 	if (err < 0)
11010 		return err;
11011 	err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11012 	if (err < 0)
11013 		return err;
11014 	err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11015 	if (err < 0)
11016 		return err;
11017 
11018 	vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11019 		alc262_check_volbit(cfg->speaker_pins[0]) |
11020 		alc262_check_volbit(cfg->hp_pins[0]);
11021 	if (vbits == 1 || vbits == 2)
11022 		pfx = "Master"; /* only one mixer is used */
11023 	else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11024 		pfx = "Speaker";
11025 	else
11026 		pfx = "Front";
11027 	vbits = 0;
11028 	err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11029 	if (err < 0)
11030 		return err;
11031 	err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11032 				     &vbits);
11033 	if (err < 0)
11034 		return err;
11035 	err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11036 				     &vbits);
11037 	if (err < 0)
11038 		return err;
11039 	return 0;
11040 }
11041 
11042 #define alc262_auto_create_input_ctls \
11043 	alc880_auto_create_input_ctls
11044 
11045 /*
11046  * generic initialization of ADC, input mixers and output mixers
11047  */
11048 static struct hda_verb alc262_volume_init_verbs[] = {
11049 	/*
11050 	 * Unmute ADC0-2 and set the default input to mic-in
11051 	 */
11052 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11053 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11054 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11055 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11056 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11057 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11058 
11059 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11060 	 * mixer widget
11061 	 * Note: PASD motherboards uses the Line In 2 as the input for
11062 	 * front panel mic (mic 2)
11063 	 */
11064 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11065 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11066 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11067 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11068 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11069 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11070 
11071 	/*
11072 	 * Set up output mixers (0x0c - 0x0f)
11073 	 */
11074 	/* set vol=0 to output mixers */
11075 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11076 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11077 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11078 
11079 	/* set up input amps for analog loopback */
11080 	/* Amp Indices: DAC = 0, mixer = 1 */
11081 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11082 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11083 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11084 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11085 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11086 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11087 
11088 	/* FIXME: use matrix-type input source selection */
11089 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11090 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11091 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11092 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11093 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11094 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11095 	/* Input mixer2 */
11096 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11097 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11098 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11099 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11100 	/* Input mixer3 */
11101 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11102 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11103 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11104 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11105 
11106 	{ }
11107 };
11108 
11109 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11110 	/*
11111 	 * Unmute ADC0-2 and set the default input to mic-in
11112 	 */
11113 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11114 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11115 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11116 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11117 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11118 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11119 
11120 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11121 	 * mixer widget
11122 	 * Note: PASD motherboards uses the Line In 2 as the input for
11123 	 * front panel mic (mic 2)
11124 	 */
11125 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11126 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11127 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11128 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11129 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11130 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11131 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11132         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11133 
11134 	/*
11135 	 * Set up output mixers (0x0c - 0x0e)
11136 	 */
11137 	/* set vol=0 to output mixers */
11138 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11139 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11140 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11141 
11142 	/* set up input amps for analog loopback */
11143 	/* Amp Indices: DAC = 0, mixer = 1 */
11144 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11145 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11146 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11147 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11148 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11149 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11150 
11151 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11152 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11153 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11154 
11155 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11156 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11157 
11158 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11159 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11160 
11161 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11162 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11163         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11164 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11165 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11166 
11167 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11168 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11169         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11170 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11171 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11172 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11173 
11174 
11175 	/* FIXME: use matrix-type input source selection */
11176 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11177 	/* Input mixer1: only unmute Mic */
11178 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11179 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11180 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11181 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11182 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11183 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11184 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11185 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11186 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11187 	/* Input mixer2 */
11188 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11189 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11190 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11191 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11192 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11193 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11194 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11195 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11196 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11197 	/* Input mixer3 */
11198 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11199 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11200 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11201 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11202 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11203 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11204 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11205 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11206 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11207 
11208 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11209 
11210 	{ }
11211 };
11212 
11213 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11214 	/*
11215 	 * Unmute ADC0-2 and set the default input to mic-in
11216 	 */
11217 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11218 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11219 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11220 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11221 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11222 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11223 
11224 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11225 	 * mixer widget
11226 	 * Note: PASD motherboards uses the Line In 2 as the input for front
11227 	 * panel mic (mic 2)
11228 	 */
11229 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11230 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11231 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11232 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11233 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11234 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11235 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11236 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11237 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11238 	/*
11239 	 * Set up output mixers (0x0c - 0x0e)
11240 	 */
11241 	/* set vol=0 to output mixers */
11242 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11243 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11244 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11245 
11246 	/* set up input amps for analog loopback */
11247 	/* Amp Indices: DAC = 0, mixer = 1 */
11248 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11249 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11250 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11251 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11252 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11253 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11254 
11255 
11256 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
11257 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
11258 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
11259 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
11260 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
11261 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
11262 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
11263 
11264 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11265 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11266 
11267 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11268 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11269 
11270 	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11271 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11272 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11273 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11274 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11275 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11276 
11277 	/* FIXME: use matrix-type input source selection */
11278 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11279 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11280 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11281 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11282 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11283 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11284 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11285         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11286 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11287 	/* Input mixer2 */
11288 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11289 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11290 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11291 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11292 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11293         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11294 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11295 	/* Input mixer3 */
11296 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11297 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11298 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11299 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11300 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11301         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11302 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11303 
11304 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11305 
11306 	{ }
11307 };
11308 
11309 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11310 
11311 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
11312 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11313 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11314 
11315 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
11316 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
11317 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11318 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11319 
11320 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
11321 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11322 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11323 	{}
11324 };
11325 
11326 
11327 #ifdef CONFIG_SND_HDA_POWER_SAVE
11328 #define alc262_loopbacks	alc880_loopbacks
11329 #endif
11330 
11331 /* pcm configuration: identical with ALC880 */
11332 #define alc262_pcm_analog_playback	alc880_pcm_analog_playback
11333 #define alc262_pcm_analog_capture	alc880_pcm_analog_capture
11334 #define alc262_pcm_digital_playback	alc880_pcm_digital_playback
11335 #define alc262_pcm_digital_capture	alc880_pcm_digital_capture
11336 
11337 /*
11338  * BIOS auto configuration
11339  */
11340 static int alc262_parse_auto_config(struct hda_codec *codec)
11341 {
11342 	struct alc_spec *spec = codec->spec;
11343 	int err;
11344 	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11345 
11346 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11347 					   alc262_ignore);
11348 	if (err < 0)
11349 		return err;
11350 	if (!spec->autocfg.line_outs) {
11351 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11352 			spec->multiout.max_channels = 2;
11353 			spec->no_analog = 1;
11354 			goto dig_only;
11355 		}
11356 		return 0; /* can't find valid BIOS pin config */
11357 	}
11358 	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11359 	if (err < 0)
11360 		return err;
11361 	err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11362 	if (err < 0)
11363 		return err;
11364 
11365 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11366 
11367  dig_only:
11368 	if (spec->autocfg.dig_outs) {
11369 		spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11370 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
11371 	}
11372 	if (spec->autocfg.dig_in_pin)
11373 		spec->dig_in_nid = ALC262_DIGIN_NID;
11374 
11375 	if (spec->kctls.list)
11376 		add_mixer(spec, spec->kctls.list);
11377 
11378 	add_verb(spec, alc262_volume_init_verbs);
11379 	spec->num_mux_defs = 1;
11380 	spec->input_mux = &spec->private_imux[0];
11381 
11382 	err = alc_auto_add_mic_boost(codec);
11383 	if (err < 0)
11384 		return err;
11385 
11386 	alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11387 
11388 	return 1;
11389 }
11390 
11391 #define alc262_auto_init_multi_out	alc882_auto_init_multi_out
11392 #define alc262_auto_init_hp_out		alc882_auto_init_hp_out
11393 #define alc262_auto_init_analog_input	alc882_auto_init_analog_input
11394 #define alc262_auto_init_input_src	alc882_auto_init_input_src
11395 
11396 
11397 /* init callback for auto-configuration model -- overriding the default init */
11398 static void alc262_auto_init(struct hda_codec *codec)
11399 {
11400 	struct alc_spec *spec = codec->spec;
11401 	alc262_auto_init_multi_out(codec);
11402 	alc262_auto_init_hp_out(codec);
11403 	alc262_auto_init_analog_input(codec);
11404 	alc262_auto_init_input_src(codec);
11405 	if (spec->unsol_event)
11406 		alc_inithook(codec);
11407 }
11408 
11409 /*
11410  * configuration and preset
11411  */
11412 static const char *alc262_models[ALC262_MODEL_LAST] = {
11413 	[ALC262_BASIC]		= "basic",
11414 	[ALC262_HIPPO]		= "hippo",
11415 	[ALC262_HIPPO_1]	= "hippo_1",
11416 	[ALC262_FUJITSU]	= "fujitsu",
11417 	[ALC262_HP_BPC]		= "hp-bpc",
11418 	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11419 	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
11420 	[ALC262_HP_RP5700]	= "hp-rp5700",
11421 	[ALC262_BENQ_ED8]	= "benq",
11422 	[ALC262_BENQ_T31]	= "benq-t31",
11423 	[ALC262_SONY_ASSAMD]	= "sony-assamd",
11424 	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
11425 	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
11426 	[ALC262_ULTRA]		= "ultra",
11427 	[ALC262_LENOVO_3000]	= "lenovo-3000",
11428 	[ALC262_NEC]		= "nec",
11429 	[ALC262_TYAN]		= "tyan",
11430 	[ALC262_AUTO]		= "auto",
11431 };
11432 
11433 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11434 	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11435 	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11436 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11437 			   ALC262_HP_BPC),
11438 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11439 			   ALC262_HP_BPC),
11440 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11441 			   ALC262_HP_BPC),
11442 	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11443 	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11444 	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11445 	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11446 	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11447 	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11448 	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11449 	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11450 	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11451 	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11452 	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11453 	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11454 		      ALC262_HP_TC_T5735),
11455 	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11456 	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11457 	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11458 	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11459 	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11460 	SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11461 	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11462 			   ALC262_SONY_ASSAMD),
11463 	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11464 		      ALC262_TOSHIBA_RX1),
11465 	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11466 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11467 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11468 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11469 	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11470 			   ALC262_ULTRA),
11471 	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11472 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11473 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11474 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11475 	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11476 	{}
11477 };
11478 
11479 static struct alc_config_preset alc262_presets[] = {
11480 	[ALC262_BASIC] = {
11481 		.mixers = { alc262_base_mixer },
11482 		.init_verbs = { alc262_init_verbs },
11483 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11484 		.dac_nids = alc262_dac_nids,
11485 		.hp_nid = 0x03,
11486 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11487 		.channel_mode = alc262_modes,
11488 		.input_mux = &alc262_capture_source,
11489 	},
11490 	[ALC262_HIPPO] = {
11491 		.mixers = { alc262_hippo_mixer },
11492 		.init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11493 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11494 		.dac_nids = alc262_dac_nids,
11495 		.hp_nid = 0x03,
11496 		.dig_out_nid = ALC262_DIGOUT_NID,
11497 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11498 		.channel_mode = alc262_modes,
11499 		.input_mux = &alc262_capture_source,
11500 		.unsol_event = alc262_hippo_unsol_event,
11501 		.setup = alc262_hippo_setup,
11502 		.init_hook = alc262_hippo_automute,
11503 	},
11504 	[ALC262_HIPPO_1] = {
11505 		.mixers = { alc262_hippo1_mixer },
11506 		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11507 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11508 		.dac_nids = alc262_dac_nids,
11509 		.hp_nid = 0x02,
11510 		.dig_out_nid = ALC262_DIGOUT_NID,
11511 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11512 		.channel_mode = alc262_modes,
11513 		.input_mux = &alc262_capture_source,
11514 		.unsol_event = alc262_hippo_unsol_event,
11515 		.setup = alc262_hippo1_setup,
11516 		.init_hook = alc262_hippo_automute,
11517 	},
11518 	[ALC262_FUJITSU] = {
11519 		.mixers = { alc262_fujitsu_mixer },
11520 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11521 				alc262_fujitsu_unsol_verbs },
11522 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11523 		.dac_nids = alc262_dac_nids,
11524 		.hp_nid = 0x03,
11525 		.dig_out_nid = ALC262_DIGOUT_NID,
11526 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11527 		.channel_mode = alc262_modes,
11528 		.input_mux = &alc262_fujitsu_capture_source,
11529 		.unsol_event = alc262_fujitsu_unsol_event,
11530 		.init_hook = alc262_fujitsu_init_hook,
11531 	},
11532 	[ALC262_HP_BPC] = {
11533 		.mixers = { alc262_HP_BPC_mixer },
11534 		.init_verbs = { alc262_HP_BPC_init_verbs },
11535 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11536 		.dac_nids = alc262_dac_nids,
11537 		.hp_nid = 0x03,
11538 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11539 		.channel_mode = alc262_modes,
11540 		.input_mux = &alc262_HP_capture_source,
11541 		.unsol_event = alc262_hp_bpc_unsol_event,
11542 		.init_hook = alc262_hp_bpc_automute,
11543 	},
11544 	[ALC262_HP_BPC_D7000_WF] = {
11545 		.mixers = { alc262_HP_BPC_WildWest_mixer },
11546 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11547 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11548 		.dac_nids = alc262_dac_nids,
11549 		.hp_nid = 0x03,
11550 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11551 		.channel_mode = alc262_modes,
11552 		.input_mux = &alc262_HP_D7000_capture_source,
11553 		.unsol_event = alc262_hp_wildwest_unsol_event,
11554 		.init_hook = alc262_hp_wildwest_automute,
11555 	},
11556 	[ALC262_HP_BPC_D7000_WL] = {
11557 		.mixers = { alc262_HP_BPC_WildWest_mixer,
11558 			    alc262_HP_BPC_WildWest_option_mixer },
11559 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11560 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11561 		.dac_nids = alc262_dac_nids,
11562 		.hp_nid = 0x03,
11563 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11564 		.channel_mode = alc262_modes,
11565 		.input_mux = &alc262_HP_D7000_capture_source,
11566 		.unsol_event = alc262_hp_wildwest_unsol_event,
11567 		.init_hook = alc262_hp_wildwest_automute,
11568 	},
11569 	[ALC262_HP_TC_T5735] = {
11570 		.mixers = { alc262_hp_t5735_mixer },
11571 		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11572 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11573 		.dac_nids = alc262_dac_nids,
11574 		.hp_nid = 0x03,
11575 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11576 		.channel_mode = alc262_modes,
11577 		.input_mux = &alc262_capture_source,
11578 		.unsol_event = alc_automute_amp_unsol_event,
11579 		.setup = alc262_hp_t5735_setup,
11580 		.init_hook = alc_automute_amp,
11581 	},
11582 	[ALC262_HP_RP5700] = {
11583 		.mixers = { alc262_hp_rp5700_mixer },
11584 		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11585 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11586 		.dac_nids = alc262_dac_nids,
11587 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11588 		.channel_mode = alc262_modes,
11589 		.input_mux = &alc262_hp_rp5700_capture_source,
11590         },
11591 	[ALC262_BENQ_ED8] = {
11592 		.mixers = { alc262_base_mixer },
11593 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11594 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11595 		.dac_nids = alc262_dac_nids,
11596 		.hp_nid = 0x03,
11597 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11598 		.channel_mode = alc262_modes,
11599 		.input_mux = &alc262_capture_source,
11600 	},
11601 	[ALC262_SONY_ASSAMD] = {
11602 		.mixers = { alc262_sony_mixer },
11603 		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11604 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11605 		.dac_nids = alc262_dac_nids,
11606 		.hp_nid = 0x02,
11607 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11608 		.channel_mode = alc262_modes,
11609 		.input_mux = &alc262_capture_source,
11610 		.unsol_event = alc262_hippo_unsol_event,
11611 		.setup = alc262_hippo_setup,
11612 		.init_hook = alc262_hippo_automute,
11613 	},
11614 	[ALC262_BENQ_T31] = {
11615 		.mixers = { alc262_benq_t31_mixer },
11616 		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11617 				alc_hp15_unsol_verbs },
11618 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11619 		.dac_nids = alc262_dac_nids,
11620 		.hp_nid = 0x03,
11621 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11622 		.channel_mode = alc262_modes,
11623 		.input_mux = &alc262_capture_source,
11624 		.unsol_event = alc262_hippo_unsol_event,
11625 		.setup = alc262_hippo_setup,
11626 		.init_hook = alc262_hippo_automute,
11627 	},
11628 	[ALC262_ULTRA] = {
11629 		.mixers = { alc262_ultra_mixer },
11630 		.cap_mixer = alc262_ultra_capture_mixer,
11631 		.init_verbs = { alc262_ultra_verbs },
11632 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11633 		.dac_nids = alc262_dac_nids,
11634 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11635 		.channel_mode = alc262_modes,
11636 		.input_mux = &alc262_ultra_capture_source,
11637 		.adc_nids = alc262_adc_nids, /* ADC0 */
11638 		.capsrc_nids = alc262_capsrc_nids,
11639 		.num_adc_nids = 1, /* single ADC */
11640 		.unsol_event = alc262_ultra_unsol_event,
11641 		.init_hook = alc262_ultra_automute,
11642 	},
11643 	[ALC262_LENOVO_3000] = {
11644 		.mixers = { alc262_lenovo_3000_mixer },
11645 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11646 				alc262_lenovo_3000_unsol_verbs },
11647 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11648 		.dac_nids = alc262_dac_nids,
11649 		.hp_nid = 0x03,
11650 		.dig_out_nid = ALC262_DIGOUT_NID,
11651 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11652 		.channel_mode = alc262_modes,
11653 		.input_mux = &alc262_fujitsu_capture_source,
11654 		.unsol_event = alc262_lenovo_3000_unsol_event,
11655 	},
11656 	[ALC262_NEC] = {
11657 		.mixers = { alc262_nec_mixer },
11658 		.init_verbs = { alc262_nec_verbs },
11659 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11660 		.dac_nids = alc262_dac_nids,
11661 		.hp_nid = 0x03,
11662 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11663 		.channel_mode = alc262_modes,
11664 		.input_mux = &alc262_capture_source,
11665 	},
11666 	[ALC262_TOSHIBA_S06] = {
11667 		.mixers = { alc262_toshiba_s06_mixer },
11668 		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11669 							alc262_eapd_verbs },
11670 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11671 		.capsrc_nids = alc262_dmic_capsrc_nids,
11672 		.dac_nids = alc262_dac_nids,
11673 		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11674 		.num_adc_nids = 1, /* single ADC */
11675 		.dig_out_nid = ALC262_DIGOUT_NID,
11676 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11677 		.channel_mode = alc262_modes,
11678 		.unsol_event = alc_sku_unsol_event,
11679 		.setup = alc262_toshiba_s06_setup,
11680 		.init_hook = alc_inithook,
11681 	},
11682 	[ALC262_TOSHIBA_RX1] = {
11683 		.mixers = { alc262_toshiba_rx1_mixer },
11684 		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11685 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11686 		.dac_nids = alc262_dac_nids,
11687 		.hp_nid = 0x03,
11688 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11689 		.channel_mode = alc262_modes,
11690 		.input_mux = &alc262_capture_source,
11691 		.unsol_event = alc262_hippo_unsol_event,
11692 		.setup = alc262_hippo_setup,
11693 		.init_hook = alc262_hippo_automute,
11694 	},
11695 	[ALC262_TYAN] = {
11696 		.mixers = { alc262_tyan_mixer },
11697 		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11698 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11699 		.dac_nids = alc262_dac_nids,
11700 		.hp_nid = 0x02,
11701 		.dig_out_nid = ALC262_DIGOUT_NID,
11702 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11703 		.channel_mode = alc262_modes,
11704 		.input_mux = &alc262_capture_source,
11705 		.unsol_event = alc_automute_amp_unsol_event,
11706 		.setup = alc262_tyan_setup,
11707 		.init_hook = alc_automute_amp,
11708 	},
11709 };
11710 
11711 static int patch_alc262(struct hda_codec *codec)
11712 {
11713 	struct alc_spec *spec;
11714 	int board_config;
11715 	int err;
11716 
11717 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11718 	if (spec == NULL)
11719 		return -ENOMEM;
11720 
11721 	codec->spec = spec;
11722 #if 0
11723 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11724 	 * under-run
11725 	 */
11726 	{
11727 	int tmp;
11728 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11729 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11730 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11731 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11732 	}
11733 #endif
11734 
11735 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11736 
11737 	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11738 						  alc262_models,
11739 						  alc262_cfg_tbl);
11740 
11741 	if (board_config < 0) {
11742 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11743 		       codec->chip_name);
11744 		board_config = ALC262_AUTO;
11745 	}
11746 
11747 	if (board_config == ALC262_AUTO) {
11748 		/* automatic parse from the BIOS config */
11749 		err = alc262_parse_auto_config(codec);
11750 		if (err < 0) {
11751 			alc_free(codec);
11752 			return err;
11753 		} else if (!err) {
11754 			printk(KERN_INFO
11755 			       "hda_codec: Cannot set up configuration "
11756 			       "from BIOS.  Using base mode...\n");
11757 			board_config = ALC262_BASIC;
11758 		}
11759 	}
11760 
11761 	if (!spec->no_analog) {
11762 		err = snd_hda_attach_beep_device(codec, 0x1);
11763 		if (err < 0) {
11764 			alc_free(codec);
11765 			return err;
11766 		}
11767 	}
11768 
11769 	if (board_config != ALC262_AUTO)
11770 		setup_preset(codec, &alc262_presets[board_config]);
11771 
11772 	spec->stream_analog_playback = &alc262_pcm_analog_playback;
11773 	spec->stream_analog_capture = &alc262_pcm_analog_capture;
11774 
11775 	spec->stream_digital_playback = &alc262_pcm_digital_playback;
11776 	spec->stream_digital_capture = &alc262_pcm_digital_capture;
11777 
11778 	if (!spec->adc_nids && spec->input_mux) {
11779 		int i;
11780 		/* check whether the digital-mic has to be supported */
11781 		for (i = 0; i < spec->input_mux->num_items; i++) {
11782 			if (spec->input_mux->items[i].index >= 9)
11783 				break;
11784 		}
11785 		if (i < spec->input_mux->num_items) {
11786 			/* use only ADC0 */
11787 			spec->adc_nids = alc262_dmic_adc_nids;
11788 			spec->num_adc_nids = 1;
11789 			spec->capsrc_nids = alc262_dmic_capsrc_nids;
11790 		} else {
11791 			/* all analog inputs */
11792 			/* check whether NID 0x07 is valid */
11793 			unsigned int wcap = get_wcaps(codec, 0x07);
11794 
11795 			/* get type */
11796 			wcap = get_wcaps_type(wcap);
11797 			if (wcap != AC_WID_AUD_IN) {
11798 				spec->adc_nids = alc262_adc_nids_alt;
11799 				spec->num_adc_nids =
11800 					ARRAY_SIZE(alc262_adc_nids_alt);
11801 				spec->capsrc_nids = alc262_capsrc_nids_alt;
11802 			} else {
11803 				spec->adc_nids = alc262_adc_nids;
11804 				spec->num_adc_nids =
11805 					ARRAY_SIZE(alc262_adc_nids);
11806 				spec->capsrc_nids = alc262_capsrc_nids;
11807 			}
11808 		}
11809 	}
11810 	if (!spec->cap_mixer && !spec->no_analog)
11811 		set_capture_mixer(codec);
11812 	if (!spec->no_analog)
11813 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11814 
11815 	spec->vmaster_nid = 0x0c;
11816 
11817 	codec->patch_ops = alc_patch_ops;
11818 	if (board_config == ALC262_AUTO)
11819 		spec->init_hook = alc262_auto_init;
11820 #ifdef CONFIG_SND_HDA_POWER_SAVE
11821 	if (!spec->loopback.amplist)
11822 		spec->loopback.amplist = alc262_loopbacks;
11823 #endif
11824 	codec->proc_widget_hook = print_realtek_coef;
11825 
11826 	return 0;
11827 }
11828 
11829 /*
11830  *  ALC268 channel source setting (2 channel)
11831  */
11832 #define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
11833 #define alc268_modes		alc260_modes
11834 
11835 static hda_nid_t alc268_dac_nids[2] = {
11836 	/* front, hp */
11837 	0x02, 0x03
11838 };
11839 
11840 static hda_nid_t alc268_adc_nids[2] = {
11841 	/* ADC0-1 */
11842 	0x08, 0x07
11843 };
11844 
11845 static hda_nid_t alc268_adc_nids_alt[1] = {
11846 	/* ADC0 */
11847 	0x08
11848 };
11849 
11850 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11851 
11852 static struct snd_kcontrol_new alc268_base_mixer[] = {
11853 	/* output mixer control */
11854 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11855 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11856 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11857 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11858 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11859 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11860 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11861 	{ }
11862 };
11863 
11864 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11865 	/* output mixer control */
11866 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11867 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11868 	ALC262_HIPPO_MASTER_SWITCH,
11869 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11870 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11871 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11872 	{ }
11873 };
11874 
11875 /* bind Beep switches of both NID 0x0f and 0x10 */
11876 static struct hda_bind_ctls alc268_bind_beep_sw = {
11877 	.ops = &snd_hda_bind_sw,
11878 	.values = {
11879 		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11880 		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11881 		0
11882 	},
11883 };
11884 
11885 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11886 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11887 	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11888 	{ }
11889 };
11890 
11891 static struct hda_verb alc268_eapd_verbs[] = {
11892 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11893 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11894 	{ }
11895 };
11896 
11897 /* Toshiba specific */
11898 static struct hda_verb alc268_toshiba_verbs[] = {
11899 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11900 	{ } /* end */
11901 };
11902 
11903 /* Acer specific */
11904 /* bind volumes of both NID 0x02 and 0x03 */
11905 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11906 	.ops = &snd_hda_bind_vol,
11907 	.values = {
11908 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11909 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11910 		0
11911 	},
11912 };
11913 
11914 /* mute/unmute internal speaker according to the hp jack and mute state */
11915 static void alc268_acer_automute(struct hda_codec *codec, int force)
11916 {
11917 	struct alc_spec *spec = codec->spec;
11918 	unsigned int mute;
11919 
11920 	if (force || !spec->sense_updated) {
11921 		unsigned int present;
11922 		present = snd_hda_codec_read(codec, 0x14, 0,
11923 				    	 AC_VERB_GET_PIN_SENSE, 0);
11924 		spec->jack_present = (present & 0x80000000) != 0;
11925 		spec->sense_updated = 1;
11926 	}
11927 	if (spec->jack_present)
11928 		mute = HDA_AMP_MUTE; /* mute internal speaker */
11929 	else /* unmute internal speaker if necessary */
11930 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11931 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11932 				 HDA_AMP_MUTE, mute);
11933 }
11934 
11935 
11936 /* bind hp and internal speaker mute (with plug check) */
11937 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11938 				     struct snd_ctl_elem_value *ucontrol)
11939 {
11940 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11941 	long *valp = ucontrol->value.integer.value;
11942 	int change;
11943 
11944 	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11945 	if (change)
11946 		alc268_acer_automute(codec, 0);
11947 	return change;
11948 }
11949 
11950 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11951 	/* output mixer control */
11952 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11953 	{
11954 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11955 		.name = "Master Playback Switch",
11956 		.info = snd_hda_mixer_amp_switch_info,
11957 		.get = snd_hda_mixer_amp_switch_get,
11958 		.put = alc268_acer_master_sw_put,
11959 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11960 	},
11961 	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11962 	{ }
11963 };
11964 
11965 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11966 	/* output mixer control */
11967 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11968 	{
11969 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11970 		.name = "Master Playback Switch",
11971 		.info = snd_hda_mixer_amp_switch_info,
11972 		.get = snd_hda_mixer_amp_switch_get,
11973 		.put = alc268_acer_master_sw_put,
11974 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11975 	},
11976 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11977 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11978 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11979 	{ }
11980 };
11981 
11982 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11983 	/* output mixer control */
11984 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11985 	{
11986 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11987 		.name = "Master Playback Switch",
11988 		.info = snd_hda_mixer_amp_switch_info,
11989 		.get = snd_hda_mixer_amp_switch_get,
11990 		.put = alc268_acer_master_sw_put,
11991 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11992 	},
11993 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11994 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11995 	{ }
11996 };
11997 
11998 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11999 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12000 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12001 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12002 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12003 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12004 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12005 	{ }
12006 };
12007 
12008 static struct hda_verb alc268_acer_verbs[] = {
12009 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12010 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12011 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12012 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12013 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12014 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12015 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12016 	{ }
12017 };
12018 
12019 /* unsolicited event for HP jack sensing */
12020 #define alc268_toshiba_unsol_event	alc262_hippo_unsol_event
12021 #define alc268_toshiba_setup		alc262_hippo_setup
12022 #define alc268_toshiba_automute		alc262_hippo_automute
12023 
12024 static void alc268_acer_unsol_event(struct hda_codec *codec,
12025 				       unsigned int res)
12026 {
12027 	if ((res >> 26) != ALC880_HP_EVENT)
12028 		return;
12029 	alc268_acer_automute(codec, 1);
12030 }
12031 
12032 static void alc268_acer_init_hook(struct hda_codec *codec)
12033 {
12034 	alc268_acer_automute(codec, 1);
12035 }
12036 
12037 /* toggle speaker-output according to the hp-jack state */
12038 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12039 {
12040 	unsigned int present;
12041 	unsigned char bits;
12042 
12043 	present = snd_hda_codec_read(codec, 0x15, 0,
12044 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12045 	bits = present ? AMP_IN_MUTE(0) : 0;
12046 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12047 				AMP_IN_MUTE(0), bits);
12048 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12049 				AMP_IN_MUTE(0), bits);
12050 }
12051 
12052 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12053 				    unsigned int res)
12054 {
12055 	switch (res >> 26) {
12056 	case ALC880_HP_EVENT:
12057 		alc268_aspire_one_speaker_automute(codec);
12058 		break;
12059 	case ALC880_MIC_EVENT:
12060 		alc_mic_automute(codec);
12061 		break;
12062 	}
12063 }
12064 
12065 static void alc268_acer_lc_setup(struct hda_codec *codec)
12066 {
12067 	struct alc_spec *spec = codec->spec;
12068 	spec->ext_mic.pin = 0x18;
12069 	spec->ext_mic.mux_idx = 0;
12070 	spec->int_mic.pin = 0x12;
12071 	spec->int_mic.mux_idx = 6;
12072 	spec->auto_mic = 1;
12073 }
12074 
12075 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12076 {
12077 	alc268_aspire_one_speaker_automute(codec);
12078 	alc_mic_automute(codec);
12079 }
12080 
12081 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12082 	/* output mixer control */
12083 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12084 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12085 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12086 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12087 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12088 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12089 	{ }
12090 };
12091 
12092 static struct hda_verb alc268_dell_verbs[] = {
12093 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12094 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12095 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12096 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12097 	{ }
12098 };
12099 
12100 /* mute/unmute internal speaker according to the hp jack and mute state */
12101 static void alc268_dell_setup(struct hda_codec *codec)
12102 {
12103 	struct alc_spec *spec = codec->spec;
12104 
12105 	spec->autocfg.hp_pins[0] = 0x15;
12106 	spec->autocfg.speaker_pins[0] = 0x14;
12107 	spec->ext_mic.pin = 0x18;
12108 	spec->ext_mic.mux_idx = 0;
12109 	spec->int_mic.pin = 0x19;
12110 	spec->int_mic.mux_idx = 1;
12111 	spec->auto_mic = 1;
12112 }
12113 
12114 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12115 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12116 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12117 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12118 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12119 	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12120 	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12121 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12122 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12123 	{ }
12124 };
12125 
12126 static struct hda_verb alc267_quanta_il1_verbs[] = {
12127 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12128 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12129 	{ }
12130 };
12131 
12132 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12133 {
12134 	struct alc_spec *spec = codec->spec;
12135 	spec->autocfg.hp_pins[0] = 0x15;
12136 	spec->autocfg.speaker_pins[0] = 0x14;
12137 	spec->ext_mic.pin = 0x18;
12138 	spec->ext_mic.mux_idx = 0;
12139 	spec->int_mic.pin = 0x19;
12140 	spec->int_mic.mux_idx = 1;
12141 	spec->auto_mic = 1;
12142 }
12143 
12144 /*
12145  * generic initialization of ADC, input mixers and output mixers
12146  */
12147 static struct hda_verb alc268_base_init_verbs[] = {
12148 	/* Unmute DAC0-1 and set vol = 0 */
12149 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12150 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12151 
12152 	/*
12153 	 * Set up output mixers (0x0c - 0x0e)
12154 	 */
12155 	/* set vol=0 to output mixers */
12156 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12157         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12158 
12159 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12160 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12161 
12162 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12163 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12164 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12165 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12166 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12167 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12168 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12169 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12170 
12171 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12172 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12173 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12174 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12175 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12176 
12177 	/* set PCBEEP vol = 0, mute connections */
12178 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12179 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12180 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12181 
12182 	/* Unmute Selector 23h,24h and set the default input to mic-in */
12183 
12184 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12185 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12186 	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12187 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12188 
12189 	{ }
12190 };
12191 
12192 /*
12193  * generic initialization of ADC, input mixers and output mixers
12194  */
12195 static struct hda_verb alc268_volume_init_verbs[] = {
12196 	/* set output DAC */
12197 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12198 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12199 
12200 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12201 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12202 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12203 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12204 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12205 
12206 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12207 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12208 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12209 
12210 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12211 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12212 
12213 	/* set PCBEEP vol = 0, mute connections */
12214 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12215 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12216 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12217 
12218 	{ }
12219 };
12220 
12221 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12222 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12223 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12224 	{ } /* end */
12225 };
12226 
12227 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12228 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12229 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12230 	_DEFINE_CAPSRC(1),
12231 	{ } /* end */
12232 };
12233 
12234 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12235 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12236 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12237 	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12238 	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12239 	_DEFINE_CAPSRC(2),
12240 	{ } /* end */
12241 };
12242 
12243 static struct hda_input_mux alc268_capture_source = {
12244 	.num_items = 4,
12245 	.items = {
12246 		{ "Mic", 0x0 },
12247 		{ "Front Mic", 0x1 },
12248 		{ "Line", 0x2 },
12249 		{ "CD", 0x3 },
12250 	},
12251 };
12252 
12253 static struct hda_input_mux alc268_acer_capture_source = {
12254 	.num_items = 3,
12255 	.items = {
12256 		{ "Mic", 0x0 },
12257 		{ "Internal Mic", 0x1 },
12258 		{ "Line", 0x2 },
12259 	},
12260 };
12261 
12262 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12263 	.num_items = 3,
12264 	.items = {
12265 		{ "Mic", 0x0 },
12266 		{ "Internal Mic", 0x6 },
12267 		{ "Line", 0x2 },
12268 	},
12269 };
12270 
12271 #ifdef CONFIG_SND_DEBUG
12272 static struct snd_kcontrol_new alc268_test_mixer[] = {
12273 	/* Volume widgets */
12274 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12275 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12276 	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12277 	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12278 	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12279 	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12280 	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12281 	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12282 	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12283 	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12284 	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12285 	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12286 	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12287 	/* The below appears problematic on some hardwares */
12288 	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12289 	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12290 	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12291 	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12292 	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12293 
12294 	/* Modes for retasking pin widgets */
12295 	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12296 	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12297 	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12298 	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12299 
12300 	/* Controls for GPIO pins, assuming they are configured as outputs */
12301 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12302 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12303 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12304 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12305 
12306 	/* Switches to allow the digital SPDIF output pin to be enabled.
12307 	 * The ALC268 does not have an SPDIF input.
12308 	 */
12309 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12310 
12311 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
12312 	 * this output to turn on an external amplifier.
12313 	 */
12314 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12315 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12316 
12317 	{ } /* end */
12318 };
12319 #endif
12320 
12321 /* create input playback/capture controls for the given pin */
12322 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12323 				    const char *ctlname, int idx)
12324 {
12325 	char name[32];
12326 	hda_nid_t dac;
12327 	int err;
12328 
12329 	sprintf(name, "%s Playback Volume", ctlname);
12330 	switch (nid) {
12331 	case 0x14:
12332 	case 0x16:
12333 		dac = 0x02;
12334 		break;
12335 	case 0x15:
12336 		dac = 0x03;
12337 		break;
12338 	default:
12339 		return 0;
12340 	}
12341 	if (spec->multiout.dac_nids[0] != dac &&
12342 	    spec->multiout.dac_nids[1] != dac) {
12343 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
12344 				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12345 						      HDA_OUTPUT));
12346 		if (err < 0)
12347 			return err;
12348 		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12349 	}
12350 
12351 	sprintf(name, "%s Playback Switch", ctlname);
12352 	if (nid != 0x16)
12353 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12354 			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12355 	else /* mono */
12356 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12357 			  HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12358 	if (err < 0)
12359 		return err;
12360 	return 0;
12361 }
12362 
12363 /* add playback controls from the parsed DAC table */
12364 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12365 					     const struct auto_pin_cfg *cfg)
12366 {
12367 	hda_nid_t nid;
12368 	int err;
12369 
12370 	spec->multiout.dac_nids = spec->private_dac_nids;
12371 
12372 	nid = cfg->line_out_pins[0];
12373 	if (nid) {
12374 		const char *name;
12375 		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12376 			name = "Speaker";
12377 		else
12378 			name = "Front";
12379 		err = alc268_new_analog_output(spec, nid, name, 0);
12380 		if (err < 0)
12381 			return err;
12382 	}
12383 
12384 	nid = cfg->speaker_pins[0];
12385 	if (nid == 0x1d) {
12386 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
12387 				  "Speaker Playback Volume",
12388 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12389 		if (err < 0)
12390 			return err;
12391 	} else {
12392 		err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12393 		if (err < 0)
12394 			return err;
12395 	}
12396 	nid = cfg->hp_pins[0];
12397 	if (nid) {
12398 		err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12399 		if (err < 0)
12400 			return err;
12401 	}
12402 
12403 	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12404 	if (nid == 0x16) {
12405 		err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12406 				  "Mono Playback Switch",
12407 				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12408 		if (err < 0)
12409 			return err;
12410 	}
12411 	return 0;
12412 }
12413 
12414 /* create playback/capture controls for input pins */
12415 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12416 						const struct auto_pin_cfg *cfg)
12417 {
12418 	return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12419 }
12420 
12421 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12422 					      hda_nid_t nid, int pin_type)
12423 {
12424 	int idx;
12425 
12426 	alc_set_pin_output(codec, nid, pin_type);
12427 	if (nid == 0x14 || nid == 0x16)
12428 		idx = 0;
12429 	else
12430 		idx = 1;
12431 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12432 }
12433 
12434 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12435 {
12436 	struct alc_spec *spec = codec->spec;
12437 	hda_nid_t nid = spec->autocfg.line_out_pins[0];
12438 	if (nid) {
12439 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
12440 		alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12441 	}
12442 }
12443 
12444 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12445 {
12446 	struct alc_spec *spec = codec->spec;
12447 	hda_nid_t pin;
12448 
12449 	pin = spec->autocfg.hp_pins[0];
12450 	if (pin)
12451 		alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12452 	pin = spec->autocfg.speaker_pins[0];
12453 	if (pin)
12454 		alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12455 }
12456 
12457 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12458 {
12459 	struct alc_spec *spec = codec->spec;
12460 	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12461 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12462 	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12463 	unsigned int	dac_vol1, dac_vol2;
12464 
12465 	if (line_nid == 0x1d || speaker_nid == 0x1d) {
12466 		snd_hda_codec_write(codec, speaker_nid, 0,
12467 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12468 		/* mute mixer inputs from 0x1d */
12469 		snd_hda_codec_write(codec, 0x0f, 0,
12470 				    AC_VERB_SET_AMP_GAIN_MUTE,
12471 				    AMP_IN_UNMUTE(1));
12472 		snd_hda_codec_write(codec, 0x10, 0,
12473 				    AC_VERB_SET_AMP_GAIN_MUTE,
12474 				    AMP_IN_UNMUTE(1));
12475 	} else {
12476 		/* unmute mixer inputs from 0x1d */
12477 		snd_hda_codec_write(codec, 0x0f, 0,
12478 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12479 		snd_hda_codec_write(codec, 0x10, 0,
12480 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12481 	}
12482 
12483 	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
12484 	if (line_nid == 0x14)
12485 		dac_vol2 = AMP_OUT_ZERO;
12486 	else if (line_nid == 0x15)
12487 		dac_vol1 = AMP_OUT_ZERO;
12488 	if (hp_nid == 0x14)
12489 		dac_vol2 = AMP_OUT_ZERO;
12490 	else if (hp_nid == 0x15)
12491 		dac_vol1 = AMP_OUT_ZERO;
12492 	if (line_nid != 0x16 || hp_nid != 0x16 ||
12493 	    spec->autocfg.line_out_pins[1] != 0x16 ||
12494 	    spec->autocfg.line_out_pins[2] != 0x16)
12495 		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12496 
12497 	snd_hda_codec_write(codec, 0x02, 0,
12498 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12499 	snd_hda_codec_write(codec, 0x03, 0,
12500 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12501 }
12502 
12503 /* pcm configuration: identical with ALC880 */
12504 #define alc268_pcm_analog_playback	alc880_pcm_analog_playback
12505 #define alc268_pcm_analog_capture	alc880_pcm_analog_capture
12506 #define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
12507 #define alc268_pcm_digital_playback	alc880_pcm_digital_playback
12508 
12509 /*
12510  * BIOS auto configuration
12511  */
12512 static int alc268_parse_auto_config(struct hda_codec *codec)
12513 {
12514 	struct alc_spec *spec = codec->spec;
12515 	int err;
12516 	static hda_nid_t alc268_ignore[] = { 0 };
12517 
12518 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12519 					   alc268_ignore);
12520 	if (err < 0)
12521 		return err;
12522 	if (!spec->autocfg.line_outs) {
12523 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12524 			spec->multiout.max_channels = 2;
12525 			spec->no_analog = 1;
12526 			goto dig_only;
12527 		}
12528 		return 0; /* can't find valid BIOS pin config */
12529 	}
12530 	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12531 	if (err < 0)
12532 		return err;
12533 	err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
12534 	if (err < 0)
12535 		return err;
12536 
12537 	spec->multiout.max_channels = 2;
12538 
12539  dig_only:
12540 	/* digital only support output */
12541 	if (spec->autocfg.dig_outs) {
12542 		spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12543 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
12544 	}
12545 	if (spec->kctls.list)
12546 		add_mixer(spec, spec->kctls.list);
12547 
12548 	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12549 		add_mixer(spec, alc268_beep_mixer);
12550 
12551 	add_verb(spec, alc268_volume_init_verbs);
12552 	spec->num_mux_defs = 2;
12553 	spec->input_mux = &spec->private_imux[0];
12554 
12555 	err = alc_auto_add_mic_boost(codec);
12556 	if (err < 0)
12557 		return err;
12558 
12559 	alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12560 
12561 	return 1;
12562 }
12563 
12564 #define alc268_auto_init_analog_input	alc882_auto_init_analog_input
12565 
12566 /* init callback for auto-configuration model -- overriding the default init */
12567 static void alc268_auto_init(struct hda_codec *codec)
12568 {
12569 	struct alc_spec *spec = codec->spec;
12570 	alc268_auto_init_multi_out(codec);
12571 	alc268_auto_init_hp_out(codec);
12572 	alc268_auto_init_mono_speaker_out(codec);
12573 	alc268_auto_init_analog_input(codec);
12574 	if (spec->unsol_event)
12575 		alc_inithook(codec);
12576 }
12577 
12578 /*
12579  * configuration and preset
12580  */
12581 static const char *alc268_models[ALC268_MODEL_LAST] = {
12582 	[ALC267_QUANTA_IL1]	= "quanta-il1",
12583 	[ALC268_3ST]		= "3stack",
12584 	[ALC268_TOSHIBA]	= "toshiba",
12585 	[ALC268_ACER]		= "acer",
12586 	[ALC268_ACER_DMIC]	= "acer-dmic",
12587 	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
12588 	[ALC268_DELL]		= "dell",
12589 	[ALC268_ZEPTO]		= "zepto",
12590 #ifdef CONFIG_SND_DEBUG
12591 	[ALC268_TEST]		= "test",
12592 #endif
12593 	[ALC268_AUTO]		= "auto",
12594 };
12595 
12596 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12597 	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12598 	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12599 	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12600 	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12601 	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12602 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12603 						ALC268_ACER_ASPIRE_ONE),
12604 	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12605 	SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12606 	/* almost compatible with toshiba but with optional digital outs;
12607 	 * auto-probing seems working fine
12608 	 */
12609 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12610 			   ALC268_AUTO),
12611 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12612 	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12613 	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12614 	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12615 	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12616 	SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12617 	{}
12618 };
12619 
12620 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
12621 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
12622 	SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
12623 	SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
12624 	SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12625 			   ALC268_TOSHIBA),
12626 	{}
12627 };
12628 
12629 static struct alc_config_preset alc268_presets[] = {
12630 	[ALC267_QUANTA_IL1] = {
12631 		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
12632 			    alc268_capture_nosrc_mixer },
12633 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12634 				alc267_quanta_il1_verbs },
12635 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12636 		.dac_nids = alc268_dac_nids,
12637 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12638 		.adc_nids = alc268_adc_nids_alt,
12639 		.hp_nid = 0x03,
12640 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12641 		.channel_mode = alc268_modes,
12642 		.unsol_event = alc_sku_unsol_event,
12643 		.setup = alc267_quanta_il1_setup,
12644 		.init_hook = alc_inithook,
12645 	},
12646 	[ALC268_3ST] = {
12647 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12648 			    alc268_beep_mixer },
12649 		.init_verbs = { alc268_base_init_verbs },
12650 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12651 		.dac_nids = alc268_dac_nids,
12652                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12653                 .adc_nids = alc268_adc_nids_alt,
12654 		.capsrc_nids = alc268_capsrc_nids,
12655 		.hp_nid = 0x03,
12656 		.dig_out_nid = ALC268_DIGOUT_NID,
12657 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12658 		.channel_mode = alc268_modes,
12659 		.input_mux = &alc268_capture_source,
12660 	},
12661 	[ALC268_TOSHIBA] = {
12662 		.mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12663 			    alc268_beep_mixer },
12664 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12665 				alc268_toshiba_verbs },
12666 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12667 		.dac_nids = alc268_dac_nids,
12668 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12669 		.adc_nids = alc268_adc_nids_alt,
12670 		.capsrc_nids = alc268_capsrc_nids,
12671 		.hp_nid = 0x03,
12672 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12673 		.channel_mode = alc268_modes,
12674 		.input_mux = &alc268_capture_source,
12675 		.unsol_event = alc268_toshiba_unsol_event,
12676 		.setup = alc268_toshiba_setup,
12677 		.init_hook = alc268_toshiba_automute,
12678 	},
12679 	[ALC268_ACER] = {
12680 		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12681 			    alc268_beep_mixer },
12682 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12683 				alc268_acer_verbs },
12684 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12685 		.dac_nids = alc268_dac_nids,
12686 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12687 		.adc_nids = alc268_adc_nids_alt,
12688 		.capsrc_nids = alc268_capsrc_nids,
12689 		.hp_nid = 0x02,
12690 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12691 		.channel_mode = alc268_modes,
12692 		.input_mux = &alc268_acer_capture_source,
12693 		.unsol_event = alc268_acer_unsol_event,
12694 		.init_hook = alc268_acer_init_hook,
12695 	},
12696 	[ALC268_ACER_DMIC] = {
12697 		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12698 			    alc268_beep_mixer },
12699 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12700 				alc268_acer_verbs },
12701 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12702 		.dac_nids = alc268_dac_nids,
12703 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12704 		.adc_nids = alc268_adc_nids_alt,
12705 		.capsrc_nids = alc268_capsrc_nids,
12706 		.hp_nid = 0x02,
12707 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12708 		.channel_mode = alc268_modes,
12709 		.input_mux = &alc268_acer_dmic_capture_source,
12710 		.unsol_event = alc268_acer_unsol_event,
12711 		.init_hook = alc268_acer_init_hook,
12712 	},
12713 	[ALC268_ACER_ASPIRE_ONE] = {
12714 		.mixers = { alc268_acer_aspire_one_mixer,
12715 			    alc268_beep_mixer,
12716 			    alc268_capture_nosrc_mixer },
12717 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12718 				alc268_acer_aspire_one_verbs },
12719 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12720 		.dac_nids = alc268_dac_nids,
12721 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12722 		.adc_nids = alc268_adc_nids_alt,
12723 		.capsrc_nids = alc268_capsrc_nids,
12724 		.hp_nid = 0x03,
12725 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12726 		.channel_mode = alc268_modes,
12727 		.unsol_event = alc268_acer_lc_unsol_event,
12728 		.setup = alc268_acer_lc_setup,
12729 		.init_hook = alc268_acer_lc_init_hook,
12730 	},
12731 	[ALC268_DELL] = {
12732 		.mixers = { alc268_dell_mixer, alc268_beep_mixer,
12733 			    alc268_capture_nosrc_mixer },
12734 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12735 				alc268_dell_verbs },
12736 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12737 		.dac_nids = alc268_dac_nids,
12738 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12739 		.adc_nids = alc268_adc_nids_alt,
12740 		.capsrc_nids = alc268_capsrc_nids,
12741 		.hp_nid = 0x02,
12742 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12743 		.channel_mode = alc268_modes,
12744 		.unsol_event = alc_sku_unsol_event,
12745 		.setup = alc268_dell_setup,
12746 		.init_hook = alc_inithook,
12747 	},
12748 	[ALC268_ZEPTO] = {
12749 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12750 			    alc268_beep_mixer },
12751 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12752 				alc268_toshiba_verbs },
12753 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12754 		.dac_nids = alc268_dac_nids,
12755 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12756 		.adc_nids = alc268_adc_nids_alt,
12757 		.capsrc_nids = alc268_capsrc_nids,
12758 		.hp_nid = 0x03,
12759 		.dig_out_nid = ALC268_DIGOUT_NID,
12760 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12761 		.channel_mode = alc268_modes,
12762 		.input_mux = &alc268_capture_source,
12763 		.setup = alc268_toshiba_setup,
12764 		.init_hook = alc268_toshiba_automute,
12765 	},
12766 #ifdef CONFIG_SND_DEBUG
12767 	[ALC268_TEST] = {
12768 		.mixers = { alc268_test_mixer, alc268_capture_mixer },
12769 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12770 				alc268_volume_init_verbs },
12771 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
12772 		.dac_nids = alc268_dac_nids,
12773 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12774 		.adc_nids = alc268_adc_nids_alt,
12775 		.capsrc_nids = alc268_capsrc_nids,
12776 		.hp_nid = 0x03,
12777 		.dig_out_nid = ALC268_DIGOUT_NID,
12778 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
12779 		.channel_mode = alc268_modes,
12780 		.input_mux = &alc268_capture_source,
12781 	},
12782 #endif
12783 };
12784 
12785 static int patch_alc268(struct hda_codec *codec)
12786 {
12787 	struct alc_spec *spec;
12788 	int board_config;
12789 	int i, has_beep, err;
12790 
12791 	spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12792 	if (spec == NULL)
12793 		return -ENOMEM;
12794 
12795 	codec->spec = spec;
12796 
12797 	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12798 						  alc268_models,
12799 						  alc268_cfg_tbl);
12800 
12801 	if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
12802 		board_config = snd_hda_check_board_codec_sid_config(codec,
12803 			ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
12804 
12805 	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12806 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12807 		       codec->chip_name);
12808 		board_config = ALC268_AUTO;
12809 	}
12810 
12811 	if (board_config == ALC268_AUTO) {
12812 		/* automatic parse from the BIOS config */
12813 		err = alc268_parse_auto_config(codec);
12814 		if (err < 0) {
12815 			alc_free(codec);
12816 			return err;
12817 		} else if (!err) {
12818 			printk(KERN_INFO
12819 			       "hda_codec: Cannot set up configuration "
12820 			       "from BIOS.  Using base mode...\n");
12821 			board_config = ALC268_3ST;
12822 		}
12823 	}
12824 
12825 	if (board_config != ALC268_AUTO)
12826 		setup_preset(codec, &alc268_presets[board_config]);
12827 
12828 	spec->stream_analog_playback = &alc268_pcm_analog_playback;
12829 	spec->stream_analog_capture = &alc268_pcm_analog_capture;
12830 	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12831 
12832 	spec->stream_digital_playback = &alc268_pcm_digital_playback;
12833 
12834 	has_beep = 0;
12835 	for (i = 0; i < spec->num_mixers; i++) {
12836 		if (spec->mixers[i] == alc268_beep_mixer) {
12837 			has_beep = 1;
12838 			break;
12839 		}
12840 	}
12841 
12842 	if (has_beep) {
12843 		err = snd_hda_attach_beep_device(codec, 0x1);
12844 		if (err < 0) {
12845 			alc_free(codec);
12846 			return err;
12847 		}
12848 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12849 			/* override the amp caps for beep generator */
12850 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12851 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12852 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12853 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12854 					  (0 << AC_AMPCAP_MUTE_SHIFT));
12855 	}
12856 
12857 	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12858 		/* check whether NID 0x07 is valid */
12859 		unsigned int wcap = get_wcaps(codec, 0x07);
12860 		int i;
12861 
12862 		spec->capsrc_nids = alc268_capsrc_nids;
12863 		/* get type */
12864 		wcap = get_wcaps_type(wcap);
12865 		if (spec->auto_mic ||
12866 		    wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12867 			spec->adc_nids = alc268_adc_nids_alt;
12868 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12869 			if (spec->auto_mic)
12870 				fixup_automic_adc(codec);
12871 			if (spec->auto_mic || spec->input_mux->num_items == 1)
12872 				add_mixer(spec, alc268_capture_nosrc_mixer);
12873 			else
12874 				add_mixer(spec, alc268_capture_alt_mixer);
12875 		} else {
12876 			spec->adc_nids = alc268_adc_nids;
12877 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12878 			add_mixer(spec, alc268_capture_mixer);
12879 		}
12880 		/* set default input source */
12881 		for (i = 0; i < spec->num_adc_nids; i++)
12882 			snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12883 				0, AC_VERB_SET_CONNECT_SEL,
12884 				i < spec->num_mux_defs ?
12885 				spec->input_mux[i].items[0].index :
12886 				spec->input_mux->items[0].index);
12887 	}
12888 
12889 	spec->vmaster_nid = 0x02;
12890 
12891 	codec->patch_ops = alc_patch_ops;
12892 	if (board_config == ALC268_AUTO)
12893 		spec->init_hook = alc268_auto_init;
12894 
12895 	codec->proc_widget_hook = print_realtek_coef;
12896 
12897 	return 0;
12898 }
12899 
12900 /*
12901  *  ALC269 channel source setting (2 channel)
12902  */
12903 #define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
12904 
12905 #define alc269_dac_nids		alc260_dac_nids
12906 
12907 static hda_nid_t alc269_adc_nids[1] = {
12908 	/* ADC1 */
12909 	0x08,
12910 };
12911 
12912 static hda_nid_t alc269_capsrc_nids[1] = {
12913 	0x23,
12914 };
12915 
12916 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12917  *       not a mux!
12918  */
12919 
12920 #define alc269_modes		alc260_modes
12921 #define alc269_capture_source	alc880_lg_lw_capture_source
12922 
12923 static struct snd_kcontrol_new alc269_base_mixer[] = {
12924 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12925 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12926 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12927 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12928 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12929 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12930 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12931 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12932 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12933 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12934 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12935 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12936 	{ } /* end */
12937 };
12938 
12939 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12940 	/* output mixer control */
12941 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12942 	{
12943 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12944 		.name = "Master Playback Switch",
12945 		.info = snd_hda_mixer_amp_switch_info,
12946 		.get = snd_hda_mixer_amp_switch_get,
12947 		.put = alc268_acer_master_sw_put,
12948 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12949 	},
12950 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12951 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12952 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12953 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12954 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12955 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12956 	{ }
12957 };
12958 
12959 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12960 	/* output mixer control */
12961 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12962 	{
12963 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12964 		.name = "Master Playback Switch",
12965 		.info = snd_hda_mixer_amp_switch_info,
12966 		.get = snd_hda_mixer_amp_switch_get,
12967 		.put = alc268_acer_master_sw_put,
12968 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12969 	},
12970 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12971 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12972 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12973 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12974 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12975 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12976 	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12977 	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12978 	HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12979 	{ }
12980 };
12981 
12982 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12983 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12984 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12985 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12986 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12987 	{ } /* end */
12988 };
12989 
12990 /* capture mixer elements */
12991 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12992 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12993 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12994 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12995 	{ } /* end */
12996 };
12997 
12998 /* FSC amilo */
12999 #define alc269_fujitsu_mixer	alc269_eeepc_mixer
13000 
13001 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13002 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13003 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13004 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13005 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13006 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13007 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13008 	{ }
13009 };
13010 
13011 static struct hda_verb alc269_lifebook_verbs[] = {
13012 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13013 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13014 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13015 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13016 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13017 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13018 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13019 	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13020 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13021 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13022 	{ }
13023 };
13024 
13025 /* toggle speaker-output according to the hp-jack state */
13026 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13027 {
13028 	unsigned int present;
13029 	unsigned char bits;
13030 
13031 	present = snd_hda_codec_read(codec, 0x15, 0,
13032 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13033 	bits = present ? AMP_IN_MUTE(0) : 0;
13034 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13035 			AMP_IN_MUTE(0), bits);
13036 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13037 			AMP_IN_MUTE(0), bits);
13038 
13039 	snd_hda_codec_write(codec, 0x20, 0,
13040 			AC_VERB_SET_COEF_INDEX, 0x0c);
13041 	snd_hda_codec_write(codec, 0x20, 0,
13042 			AC_VERB_SET_PROC_COEF, 0x680);
13043 
13044 	snd_hda_codec_write(codec, 0x20, 0,
13045 			AC_VERB_SET_COEF_INDEX, 0x0c);
13046 	snd_hda_codec_write(codec, 0x20, 0,
13047 			AC_VERB_SET_PROC_COEF, 0x480);
13048 }
13049 
13050 /* toggle speaker-output according to the hp-jacks state */
13051 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13052 {
13053 	unsigned int present;
13054 	unsigned char bits;
13055 
13056 	/* Check laptop headphone socket */
13057 	present = snd_hda_codec_read(codec, 0x15, 0,
13058 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13059 
13060 	/* Check port replicator headphone socket */
13061 	present |= snd_hda_codec_read(codec, 0x1a, 0,
13062 			AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13063 
13064 	bits = present ? AMP_IN_MUTE(0) : 0;
13065 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13066 			AMP_IN_MUTE(0), bits);
13067 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13068 			AMP_IN_MUTE(0), bits);
13069 
13070 	snd_hda_codec_write(codec, 0x20, 0,
13071 			AC_VERB_SET_COEF_INDEX, 0x0c);
13072 	snd_hda_codec_write(codec, 0x20, 0,
13073 			AC_VERB_SET_PROC_COEF, 0x680);
13074 
13075 	snd_hda_codec_write(codec, 0x20, 0,
13076 			AC_VERB_SET_COEF_INDEX, 0x0c);
13077 	snd_hda_codec_write(codec, 0x20, 0,
13078 			AC_VERB_SET_PROC_COEF, 0x480);
13079 }
13080 
13081 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13082 {
13083 	unsigned int present_laptop;
13084 	unsigned int present_dock;
13085 
13086 	present_laptop = snd_hda_codec_read(codec, 0x18, 0,
13087 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13088 
13089 	present_dock = snd_hda_codec_read(codec, 0x1b, 0,
13090 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13091 
13092 	/* Laptop mic port overrides dock mic port, design decision */
13093 	if (present_dock)
13094 		snd_hda_codec_write(codec, 0x23, 0,
13095 				AC_VERB_SET_CONNECT_SEL, 0x3);
13096 	if (present_laptop)
13097 		snd_hda_codec_write(codec, 0x23, 0,
13098 				AC_VERB_SET_CONNECT_SEL, 0x0);
13099 	if (!present_dock && !present_laptop)
13100 		snd_hda_codec_write(codec, 0x23, 0,
13101 				AC_VERB_SET_CONNECT_SEL, 0x1);
13102 }
13103 
13104 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13105 				    unsigned int res)
13106 {
13107 	switch (res >> 26) {
13108 	case ALC880_HP_EVENT:
13109 		alc269_quanta_fl1_speaker_automute(codec);
13110 		break;
13111 	case ALC880_MIC_EVENT:
13112 		alc_mic_automute(codec);
13113 		break;
13114 	}
13115 }
13116 
13117 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13118 					unsigned int res)
13119 {
13120 	if ((res >> 26) == ALC880_HP_EVENT)
13121 		alc269_lifebook_speaker_automute(codec);
13122 	if ((res >> 26) == ALC880_MIC_EVENT)
13123 		alc269_lifebook_mic_autoswitch(codec);
13124 }
13125 
13126 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13127 {
13128 	struct alc_spec *spec = codec->spec;
13129 	spec->ext_mic.pin = 0x18;
13130 	spec->ext_mic.mux_idx = 0;
13131 	spec->int_mic.pin = 0x19;
13132 	spec->int_mic.mux_idx = 1;
13133 	spec->auto_mic = 1;
13134 }
13135 
13136 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13137 {
13138 	alc269_quanta_fl1_speaker_automute(codec);
13139 	alc_mic_automute(codec);
13140 }
13141 
13142 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13143 {
13144 	alc269_lifebook_speaker_automute(codec);
13145 	alc269_lifebook_mic_autoswitch(codec);
13146 }
13147 
13148 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
13149 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13150 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13151 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13152 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13153 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13154 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13155 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13156 	{}
13157 };
13158 
13159 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
13160 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13161 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13162 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13163 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13164 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13165 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13166 	{}
13167 };
13168 
13169 /* toggle speaker-output according to the hp-jack state */
13170 static void alc269_speaker_automute(struct hda_codec *codec)
13171 {
13172 	unsigned int present;
13173 	unsigned char bits;
13174 
13175 	present = snd_hda_codec_read(codec, 0x15, 0,
13176 				AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13177 	bits = present ? AMP_IN_MUTE(0) : 0;
13178 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13179 				AMP_IN_MUTE(0), bits);
13180 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13181 				AMP_IN_MUTE(0), bits);
13182 }
13183 
13184 /* unsolicited event for HP jack sensing */
13185 static void alc269_eeepc_unsol_event(struct hda_codec *codec,
13186 				     unsigned int res)
13187 {
13188 	switch (res >> 26) {
13189 	case ALC880_HP_EVENT:
13190 		alc269_speaker_automute(codec);
13191 		break;
13192 	case ALC880_MIC_EVENT:
13193 		alc_mic_automute(codec);
13194 		break;
13195 	}
13196 }
13197 
13198 static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
13199 {
13200 	struct alc_spec *spec = codec->spec;
13201 	spec->ext_mic.pin = 0x18;
13202 	spec->ext_mic.mux_idx = 0;
13203 	spec->int_mic.pin = 0x12;
13204 	spec->int_mic.mux_idx = 5;
13205 	spec->auto_mic = 1;
13206 }
13207 
13208 static void alc269_eeepc_amic_setup(struct hda_codec *codec)
13209 {
13210 	struct alc_spec *spec = codec->spec;
13211 	spec->ext_mic.pin = 0x18;
13212 	spec->ext_mic.mux_idx = 0;
13213 	spec->int_mic.pin = 0x19;
13214 	spec->int_mic.mux_idx = 1;
13215 	spec->auto_mic = 1;
13216 }
13217 
13218 static void alc269_eeepc_inithook(struct hda_codec *codec)
13219 {
13220 	alc269_speaker_automute(codec);
13221 	alc_mic_automute(codec);
13222 }
13223 
13224 /*
13225  * generic initialization of ADC, input mixers and output mixers
13226  */
13227 static struct hda_verb alc269_init_verbs[] = {
13228 	/*
13229 	 * Unmute ADC0 and set the default input to mic-in
13230 	 */
13231 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13232 
13233 	/* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13234 	 * analog-loopback mixer widget
13235 	 * Note: PASD motherboards uses the Line In 2 as the input for
13236 	 * front panel mic (mic 2)
13237 	 */
13238 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13239 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13240 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13241 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13242 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13243 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13244 
13245 	/*
13246 	 * Set up output mixers (0x0c - 0x0e)
13247 	 */
13248 	/* set vol=0 to output mixers */
13249 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13250 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13251 
13252 	/* set up input amps for analog loopback */
13253 	/* Amp Indices: DAC = 0, mixer = 1 */
13254 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13255 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13256 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13257 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13258 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13259 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13260 
13261 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13262 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13263 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13264 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13265 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13266 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13267 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13268 
13269 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13270 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13271 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13272 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13273 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13274 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13275 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13276 
13277 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13278 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13279 
13280 	/* FIXME: use matrix-type input source selection */
13281 	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13282 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13283 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13284 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13285 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13286 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13287 
13288 	/* set EAPD */
13289 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13290 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13291 	{ }
13292 };
13293 
13294 #define alc269_auto_create_multi_out_ctls \
13295 	alc268_auto_create_multi_out_ctls
13296 #define alc269_auto_create_input_ctls \
13297 	alc268_auto_create_input_ctls
13298 
13299 #ifdef CONFIG_SND_HDA_POWER_SAVE
13300 #define alc269_loopbacks	alc880_loopbacks
13301 #endif
13302 
13303 /* pcm configuration: identical with ALC880 */
13304 #define alc269_pcm_analog_playback	alc880_pcm_analog_playback
13305 #define alc269_pcm_analog_capture	alc880_pcm_analog_capture
13306 #define alc269_pcm_digital_playback	alc880_pcm_digital_playback
13307 #define alc269_pcm_digital_capture	alc880_pcm_digital_capture
13308 
13309 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13310 	.substreams = 1,
13311 	.channels_min = 2,
13312 	.channels_max = 8,
13313 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13314 	/* NID is set in alc_build_pcms */
13315 	.ops = {
13316 		.open = alc880_playback_pcm_open,
13317 		.prepare = alc880_playback_pcm_prepare,
13318 		.cleanup = alc880_playback_pcm_cleanup
13319 	},
13320 };
13321 
13322 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13323 	.substreams = 1,
13324 	.channels_min = 2,
13325 	.channels_max = 2,
13326 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13327 	/* NID is set in alc_build_pcms */
13328 };
13329 
13330 /*
13331  * BIOS auto configuration
13332  */
13333 static int alc269_parse_auto_config(struct hda_codec *codec)
13334 {
13335 	struct alc_spec *spec = codec->spec;
13336 	int err;
13337 	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13338 
13339 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13340 					   alc269_ignore);
13341 	if (err < 0)
13342 		return err;
13343 
13344 	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13345 	if (err < 0)
13346 		return err;
13347 	err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13348 	if (err < 0)
13349 		return err;
13350 
13351 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13352 
13353 	if (spec->autocfg.dig_outs)
13354 		spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13355 
13356 	if (spec->kctls.list)
13357 		add_mixer(spec, spec->kctls.list);
13358 
13359 	add_verb(spec, alc269_init_verbs);
13360 	spec->num_mux_defs = 1;
13361 	spec->input_mux = &spec->private_imux[0];
13362 	/* set default input source */
13363 	snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13364 				  0, AC_VERB_SET_CONNECT_SEL,
13365 				  spec->input_mux->items[0].index);
13366 
13367 	err = alc_auto_add_mic_boost(codec);
13368 	if (err < 0)
13369 		return err;
13370 
13371 	if (!spec->cap_mixer && !spec->no_analog)
13372 		set_capture_mixer(codec);
13373 
13374 	alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13375 
13376 	return 1;
13377 }
13378 
13379 #define alc269_auto_init_multi_out	alc268_auto_init_multi_out
13380 #define alc269_auto_init_hp_out		alc268_auto_init_hp_out
13381 #define alc269_auto_init_analog_input	alc882_auto_init_analog_input
13382 
13383 
13384 /* init callback for auto-configuration model -- overriding the default init */
13385 static void alc269_auto_init(struct hda_codec *codec)
13386 {
13387 	struct alc_spec *spec = codec->spec;
13388 	alc269_auto_init_multi_out(codec);
13389 	alc269_auto_init_hp_out(codec);
13390 	alc269_auto_init_analog_input(codec);
13391 	if (spec->unsol_event)
13392 		alc_inithook(codec);
13393 }
13394 
13395 /*
13396  * configuration and preset
13397  */
13398 static const char *alc269_models[ALC269_MODEL_LAST] = {
13399 	[ALC269_BASIC]			= "basic",
13400 	[ALC269_QUANTA_FL1]		= "quanta",
13401 	[ALC269_ASUS_EEEPC_P703]	= "eeepc-p703",
13402 	[ALC269_ASUS_EEEPC_P901]	= "eeepc-p901",
13403 	[ALC269_FUJITSU]		= "fujitsu",
13404 	[ALC269_LIFEBOOK]		= "lifebook",
13405 	[ALC269_AUTO]			= "auto",
13406 };
13407 
13408 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13409 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13410 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13411 		      ALC269_ASUS_EEEPC_P703),
13412         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
13413         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
13414         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
13415         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
13416         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
13417         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
13418 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13419 		      ALC269_ASUS_EEEPC_P901),
13420 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13421 		      ALC269_ASUS_EEEPC_P901),
13422         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
13423 	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13424 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13425 	{}
13426 };
13427 
13428 static struct alc_config_preset alc269_presets[] = {
13429 	[ALC269_BASIC] = {
13430 		.mixers = { alc269_base_mixer },
13431 		.init_verbs = { alc269_init_verbs },
13432 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13433 		.dac_nids = alc269_dac_nids,
13434 		.hp_nid = 0x03,
13435 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13436 		.channel_mode = alc269_modes,
13437 		.input_mux = &alc269_capture_source,
13438 	},
13439 	[ALC269_QUANTA_FL1] = {
13440 		.mixers = { alc269_quanta_fl1_mixer },
13441 		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13442 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13443 		.dac_nids = alc269_dac_nids,
13444 		.hp_nid = 0x03,
13445 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13446 		.channel_mode = alc269_modes,
13447 		.input_mux = &alc269_capture_source,
13448 		.unsol_event = alc269_quanta_fl1_unsol_event,
13449 		.setup = alc269_quanta_fl1_setup,
13450 		.init_hook = alc269_quanta_fl1_init_hook,
13451 	},
13452 	[ALC269_ASUS_EEEPC_P703] = {
13453 		.mixers = { alc269_eeepc_mixer },
13454 		.cap_mixer = alc269_epc_capture_mixer,
13455 		.init_verbs = { alc269_init_verbs,
13456 				alc269_eeepc_amic_init_verbs },
13457 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13458 		.dac_nids = alc269_dac_nids,
13459 		.hp_nid = 0x03,
13460 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13461 		.channel_mode = alc269_modes,
13462 		.unsol_event = alc269_eeepc_unsol_event,
13463 		.setup = alc269_eeepc_amic_setup,
13464 		.init_hook = alc269_eeepc_inithook,
13465 	},
13466 	[ALC269_ASUS_EEEPC_P901] = {
13467 		.mixers = { alc269_eeepc_mixer },
13468 		.cap_mixer = alc269_epc_capture_mixer,
13469 		.init_verbs = { alc269_init_verbs,
13470 				alc269_eeepc_dmic_init_verbs },
13471 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13472 		.dac_nids = alc269_dac_nids,
13473 		.hp_nid = 0x03,
13474 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13475 		.channel_mode = alc269_modes,
13476 		.unsol_event = alc269_eeepc_unsol_event,
13477 		.setup = alc269_eeepc_dmic_setup,
13478 		.init_hook = alc269_eeepc_inithook,
13479 	},
13480 	[ALC269_FUJITSU] = {
13481 		.mixers = { alc269_fujitsu_mixer },
13482 		.cap_mixer = alc269_epc_capture_mixer,
13483 		.init_verbs = { alc269_init_verbs,
13484 				alc269_eeepc_dmic_init_verbs },
13485 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13486 		.dac_nids = alc269_dac_nids,
13487 		.hp_nid = 0x03,
13488 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13489 		.channel_mode = alc269_modes,
13490 		.unsol_event = alc269_eeepc_unsol_event,
13491 		.setup = alc269_eeepc_dmic_setup,
13492 		.init_hook = alc269_eeepc_inithook,
13493 	},
13494 	[ALC269_LIFEBOOK] = {
13495 		.mixers = { alc269_lifebook_mixer },
13496 		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13497 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
13498 		.dac_nids = alc269_dac_nids,
13499 		.hp_nid = 0x03,
13500 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
13501 		.channel_mode = alc269_modes,
13502 		.input_mux = &alc269_capture_source,
13503 		.unsol_event = alc269_lifebook_unsol_event,
13504 		.init_hook = alc269_lifebook_init_hook,
13505 	},
13506 };
13507 
13508 static int patch_alc269(struct hda_codec *codec)
13509 {
13510 	struct alc_spec *spec;
13511 	int board_config;
13512 	int err;
13513 
13514 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13515 	if (spec == NULL)
13516 		return -ENOMEM;
13517 
13518 	codec->spec = spec;
13519 
13520 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
13521 
13522 	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13523 						  alc269_models,
13524 						  alc269_cfg_tbl);
13525 
13526 	if (board_config < 0) {
13527 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13528 		       codec->chip_name);
13529 		board_config = ALC269_AUTO;
13530 	}
13531 
13532 	if (board_config == ALC269_AUTO) {
13533 		/* automatic parse from the BIOS config */
13534 		err = alc269_parse_auto_config(codec);
13535 		if (err < 0) {
13536 			alc_free(codec);
13537 			return err;
13538 		} else if (!err) {
13539 			printk(KERN_INFO
13540 			       "hda_codec: Cannot set up configuration "
13541 			       "from BIOS.  Using base mode...\n");
13542 			board_config = ALC269_BASIC;
13543 		}
13544 	}
13545 
13546 	err = snd_hda_attach_beep_device(codec, 0x1);
13547 	if (err < 0) {
13548 		alc_free(codec);
13549 		return err;
13550 	}
13551 
13552 	if (board_config != ALC269_AUTO)
13553 		setup_preset(codec, &alc269_presets[board_config]);
13554 
13555 	if (codec->subsystem_id == 0x17aa3bf8) {
13556 		/* Due to a hardware problem on Lenovo Ideadpad, we need to
13557 		 * fix the sample rate of analog I/O to 44.1kHz
13558 		 */
13559 		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13560 		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13561 	} else {
13562 		spec->stream_analog_playback = &alc269_pcm_analog_playback;
13563 		spec->stream_analog_capture = &alc269_pcm_analog_capture;
13564 	}
13565 	spec->stream_digital_playback = &alc269_pcm_digital_playback;
13566 	spec->stream_digital_capture = &alc269_pcm_digital_capture;
13567 
13568 	spec->adc_nids = alc269_adc_nids;
13569 	spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13570 	spec->capsrc_nids = alc269_capsrc_nids;
13571 	if (!spec->cap_mixer)
13572 		set_capture_mixer(codec);
13573 	set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13574 
13575 	spec->vmaster_nid = 0x02;
13576 
13577 	codec->patch_ops = alc_patch_ops;
13578 	if (board_config == ALC269_AUTO)
13579 		spec->init_hook = alc269_auto_init;
13580 #ifdef CONFIG_SND_HDA_POWER_SAVE
13581 	if (!spec->loopback.amplist)
13582 		spec->loopback.amplist = alc269_loopbacks;
13583 #endif
13584 	codec->proc_widget_hook = print_realtek_coef;
13585 
13586 	return 0;
13587 }
13588 
13589 /*
13590  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13591  */
13592 
13593 /*
13594  * set the path ways for 2 channel output
13595  * need to set the codec line out and mic 1 pin widgets to inputs
13596  */
13597 static struct hda_verb alc861_threestack_ch2_init[] = {
13598 	/* set pin widget 1Ah (line in) for input */
13599 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13600 	/* set pin widget 18h (mic1/2) for input, for mic also enable
13601 	 * the vref
13602 	 */
13603 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13604 
13605 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13606 #if 0
13607 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13608 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13609 #endif
13610 	{ } /* end */
13611 };
13612 /*
13613  * 6ch mode
13614  * need to set the codec line out and mic 1 pin widgets to outputs
13615  */
13616 static struct hda_verb alc861_threestack_ch6_init[] = {
13617 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
13618 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13619 	/* set pin widget 18h (mic1) for output (CLFE)*/
13620 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13621 
13622 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13623 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13624 
13625 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13626 #if 0
13627 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13628 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13629 #endif
13630 	{ } /* end */
13631 };
13632 
13633 static struct hda_channel_mode alc861_threestack_modes[2] = {
13634 	{ 2, alc861_threestack_ch2_init },
13635 	{ 6, alc861_threestack_ch6_init },
13636 };
13637 /* Set mic1 as input and unmute the mixer */
13638 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13639 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13640 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13641 	{ } /* end */
13642 };
13643 /* Set mic1 as output and mute mixer */
13644 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13645 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13646 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13647 	{ } /* end */
13648 };
13649 
13650 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13651 	{ 2, alc861_uniwill_m31_ch2_init },
13652 	{ 4, alc861_uniwill_m31_ch4_init },
13653 };
13654 
13655 /* Set mic1 and line-in as input and unmute the mixer */
13656 static struct hda_verb alc861_asus_ch2_init[] = {
13657 	/* set pin widget 1Ah (line in) for input */
13658 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13659 	/* set pin widget 18h (mic1/2) for input, for mic also enable
13660 	 * the vref
13661 	 */
13662 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13663 
13664 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13665 #if 0
13666 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13667 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13668 #endif
13669 	{ } /* end */
13670 };
13671 /* Set mic1 nad line-in as output and mute mixer */
13672 static struct hda_verb alc861_asus_ch6_init[] = {
13673 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
13674 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13675 	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13676 	/* set pin widget 18h (mic1) for output (CLFE)*/
13677 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13678 	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13679 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13680 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13681 
13682 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13683 #if 0
13684 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13685 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13686 #endif
13687 	{ } /* end */
13688 };
13689 
13690 static struct hda_channel_mode alc861_asus_modes[2] = {
13691 	{ 2, alc861_asus_ch2_init },
13692 	{ 6, alc861_asus_ch6_init },
13693 };
13694 
13695 /* patch-ALC861 */
13696 
13697 static struct snd_kcontrol_new alc861_base_mixer[] = {
13698         /* output mixer control */
13699 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13700 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13701 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13702 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13703 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13704 
13705         /*Input mixer control */
13706 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13707 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13708 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13709 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13710 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13711 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13712 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13713 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13714 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13715 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13716 
13717 	{ } /* end */
13718 };
13719 
13720 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13721         /* output mixer control */
13722 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13723 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13724 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13725 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13726 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13727 
13728 	/* Input mixer control */
13729 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13730 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13731 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13732 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13733 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13734 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13735 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13736 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13737 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13738 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13739 
13740 	{
13741 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13742 		.name = "Channel Mode",
13743 		.info = alc_ch_mode_info,
13744 		.get = alc_ch_mode_get,
13745 		.put = alc_ch_mode_put,
13746                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13747 	},
13748 	{ } /* end */
13749 };
13750 
13751 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13752         /* output mixer control */
13753 	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13754 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13755 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13756 
13757 	{ } /* end */
13758 };
13759 
13760 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13761         /* output mixer control */
13762 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13763 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13764 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13765 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13766 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13767 
13768 	/* Input mixer control */
13769 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13770 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13771 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13772 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13773 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13774 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13775 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13776 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13777 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13778 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13779 
13780 	{
13781 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13782 		.name = "Channel Mode",
13783 		.info = alc_ch_mode_info,
13784 		.get = alc_ch_mode_get,
13785 		.put = alc_ch_mode_put,
13786                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13787 	},
13788 	{ } /* end */
13789 };
13790 
13791 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13792         /* output mixer control */
13793 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13794 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13795 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13796 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13797 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13798 
13799 	/* Input mixer control */
13800 	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13801 	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13802 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13803 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13804 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13805 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13806 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13807 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13808 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13809 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13810 
13811 	{
13812 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13813 		.name = "Channel Mode",
13814 		.info = alc_ch_mode_info,
13815 		.get = alc_ch_mode_get,
13816 		.put = alc_ch_mode_put,
13817                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13818 	},
13819 	{ }
13820 };
13821 
13822 /* additional mixer */
13823 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13824 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13825 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13826 	{ }
13827 };
13828 
13829 /*
13830  * generic initialization of ADC, input mixers and output mixers
13831  */
13832 static struct hda_verb alc861_base_init_verbs[] = {
13833 	/*
13834 	 * Unmute ADC0 and set the default input to mic-in
13835 	 */
13836 	/* port-A for surround (rear panel) */
13837 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13838 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13839 	/* port-B for mic-in (rear panel) with vref */
13840 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13841 	/* port-C for line-in (rear panel) */
13842 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13843 	/* port-D for Front */
13844 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13845 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13846 	/* port-E for HP out (front panel) */
13847 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13848 	/* route front PCM to HP */
13849 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13850 	/* port-F for mic-in (front panel) with vref */
13851 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13852 	/* port-G for CLFE (rear panel) */
13853 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13854 	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13855 	/* port-H for side (rear panel) */
13856 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13857 	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13858 	/* CD-in */
13859 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13860 	/* route front mic to ADC1*/
13861 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13862 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13863 
13864 	/* Unmute DAC0~3 & spdif out*/
13865 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13866 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13867 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13868 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13869 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13870 
13871 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13872 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13873         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13874 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13875         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13876 
13877 	/* Unmute Stereo Mixer 15 */
13878 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13879 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13880 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13881 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13882 
13883 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13884 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13885 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13886 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13887 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13888 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13889 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13890 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13891 	/* hp used DAC 3 (Front) */
13892 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13893         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13894 
13895 	{ }
13896 };
13897 
13898 static struct hda_verb alc861_threestack_init_verbs[] = {
13899 	/*
13900 	 * Unmute ADC0 and set the default input to mic-in
13901 	 */
13902 	/* port-A for surround (rear panel) */
13903 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13904 	/* port-B for mic-in (rear panel) with vref */
13905 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13906 	/* port-C for line-in (rear panel) */
13907 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13908 	/* port-D for Front */
13909 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13910 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13911 	/* port-E for HP out (front panel) */
13912 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13913 	/* route front PCM to HP */
13914 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13915 	/* port-F for mic-in (front panel) with vref */
13916 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13917 	/* port-G for CLFE (rear panel) */
13918 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13919 	/* port-H for side (rear panel) */
13920 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13921 	/* CD-in */
13922 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13923 	/* route front mic to ADC1*/
13924 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13925 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13926 	/* Unmute DAC0~3 & spdif out*/
13927 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13928 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13929 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13930 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13931 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13932 
13933 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13934 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13935         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13936 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13937         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13938 
13939 	/* Unmute Stereo Mixer 15 */
13940 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13941 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13942 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13943 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13944 
13945 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13946 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13947 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13948 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13949 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13950 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13951 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13952 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13953 	/* hp used DAC 3 (Front) */
13954 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13955         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13956 	{ }
13957 };
13958 
13959 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13960 	/*
13961 	 * Unmute ADC0 and set the default input to mic-in
13962 	 */
13963 	/* port-A for surround (rear panel) */
13964 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13965 	/* port-B for mic-in (rear panel) with vref */
13966 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13967 	/* port-C for line-in (rear panel) */
13968 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13969 	/* port-D for Front */
13970 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13971 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13972 	/* port-E for HP out (front panel) */
13973 	/* this has to be set to VREF80 */
13974 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13975 	/* route front PCM to HP */
13976 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13977 	/* port-F for mic-in (front panel) with vref */
13978 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13979 	/* port-G for CLFE (rear panel) */
13980 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13981 	/* port-H for side (rear panel) */
13982 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13983 	/* CD-in */
13984 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13985 	/* route front mic to ADC1*/
13986 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13987 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13988 	/* Unmute DAC0~3 & spdif out*/
13989 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13990 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13991 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13992 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13993 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13994 
13995 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
13996 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13997         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13998 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13999         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14000 
14001 	/* Unmute Stereo Mixer 15 */
14002 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14003 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14004 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14005 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14006 
14007 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14008 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14009 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14010 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14011 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14012 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14013 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14014 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14015 	/* hp used DAC 3 (Front) */
14016 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14017         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14018 	{ }
14019 };
14020 
14021 static struct hda_verb alc861_asus_init_verbs[] = {
14022 	/*
14023 	 * Unmute ADC0 and set the default input to mic-in
14024 	 */
14025 	/* port-A for surround (rear panel)
14026 	 * according to codec#0 this is the HP jack
14027 	 */
14028 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14029 	/* route front PCM to HP */
14030 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14031 	/* port-B for mic-in (rear panel) with vref */
14032 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14033 	/* port-C for line-in (rear panel) */
14034 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14035 	/* port-D for Front */
14036 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14037 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14038 	/* port-E for HP out (front panel) */
14039 	/* this has to be set to VREF80 */
14040 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14041 	/* route front PCM to HP */
14042 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14043 	/* port-F for mic-in (front panel) with vref */
14044 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14045 	/* port-G for CLFE (rear panel) */
14046 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14047 	/* port-H for side (rear panel) */
14048 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14049 	/* CD-in */
14050 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14051 	/* route front mic to ADC1*/
14052 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14053 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14054 	/* Unmute DAC0~3 & spdif out*/
14055 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14056 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14057 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14058 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14059 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14060 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14061 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14062         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14063 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14064         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14065 
14066 	/* Unmute Stereo Mixer 15 */
14067 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14068 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14069 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14070 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14071 
14072 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14073 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14074 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14075 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14076 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14077 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14078 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14079 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14080 	/* hp used DAC 3 (Front) */
14081 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14082 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14083 	{ }
14084 };
14085 
14086 /* additional init verbs for ASUS laptops */
14087 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14088 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14089 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14090 	{ }
14091 };
14092 
14093 /*
14094  * generic initialization of ADC, input mixers and output mixers
14095  */
14096 static struct hda_verb alc861_auto_init_verbs[] = {
14097 	/*
14098 	 * Unmute ADC0 and set the default input to mic-in
14099 	 */
14100 	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14101 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14102 
14103 	/* Unmute DAC0~3 & spdif out*/
14104 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14105 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14106 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14107 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14108 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14109 
14110 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14111 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14112 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14113 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14114 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14115 
14116 	/* Unmute Stereo Mixer 15 */
14117 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14118 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14119 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14120 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14121 
14122 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14123 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14124 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14125 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14126 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14127 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14128 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14129 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14130 
14131 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14132 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14133 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14134 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14135 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14136 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14137 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14138 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14139 
14140 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
14141 
14142 	{ }
14143 };
14144 
14145 static struct hda_verb alc861_toshiba_init_verbs[] = {
14146 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14147 
14148 	{ }
14149 };
14150 
14151 /* toggle speaker-output according to the hp-jack state */
14152 static void alc861_toshiba_automute(struct hda_codec *codec)
14153 {
14154 	unsigned int present;
14155 
14156 	present = snd_hda_codec_read(codec, 0x0f, 0,
14157 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14158 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14159 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14160 	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14161 				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14162 }
14163 
14164 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14165 				       unsigned int res)
14166 {
14167 	if ((res >> 26) == ALC880_HP_EVENT)
14168 		alc861_toshiba_automute(codec);
14169 }
14170 
14171 /* pcm configuration: identical with ALC880 */
14172 #define alc861_pcm_analog_playback	alc880_pcm_analog_playback
14173 #define alc861_pcm_analog_capture	alc880_pcm_analog_capture
14174 #define alc861_pcm_digital_playback	alc880_pcm_digital_playback
14175 #define alc861_pcm_digital_capture	alc880_pcm_digital_capture
14176 
14177 
14178 #define ALC861_DIGOUT_NID	0x07
14179 
14180 static struct hda_channel_mode alc861_8ch_modes[1] = {
14181 	{ 8, NULL }
14182 };
14183 
14184 static hda_nid_t alc861_dac_nids[4] = {
14185 	/* front, surround, clfe, side */
14186 	0x03, 0x06, 0x05, 0x04
14187 };
14188 
14189 static hda_nid_t alc660_dac_nids[3] = {
14190 	/* front, clfe, surround */
14191 	0x03, 0x05, 0x06
14192 };
14193 
14194 static hda_nid_t alc861_adc_nids[1] = {
14195 	/* ADC0-2 */
14196 	0x08,
14197 };
14198 
14199 static struct hda_input_mux alc861_capture_source = {
14200 	.num_items = 5,
14201 	.items = {
14202 		{ "Mic", 0x0 },
14203 		{ "Front Mic", 0x3 },
14204 		{ "Line", 0x1 },
14205 		{ "CD", 0x4 },
14206 		{ "Mixer", 0x5 },
14207 	},
14208 };
14209 
14210 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14211 {
14212 	struct alc_spec *spec = codec->spec;
14213 	hda_nid_t mix, srcs[5];
14214 	int i, j, num;
14215 
14216 	if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14217 		return 0;
14218 	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14219 	if (num < 0)
14220 		return 0;
14221 	for (i = 0; i < num; i++) {
14222 		unsigned int type;
14223 		type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14224 		if (type != AC_WID_AUD_OUT)
14225 			continue;
14226 		for (j = 0; j < spec->multiout.num_dacs; j++)
14227 			if (spec->multiout.dac_nids[j] == srcs[i])
14228 				break;
14229 		if (j >= spec->multiout.num_dacs)
14230 			return srcs[i];
14231 	}
14232 	return 0;
14233 }
14234 
14235 /* fill in the dac_nids table from the parsed pin configuration */
14236 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14237 				     const struct auto_pin_cfg *cfg)
14238 {
14239 	struct alc_spec *spec = codec->spec;
14240 	int i;
14241 	hda_nid_t nid, dac;
14242 
14243 	spec->multiout.dac_nids = spec->private_dac_nids;
14244 	for (i = 0; i < cfg->line_outs; i++) {
14245 		nid = cfg->line_out_pins[i];
14246 		dac = alc861_look_for_dac(codec, nid);
14247 		if (!dac)
14248 			continue;
14249 		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14250 	}
14251 	return 0;
14252 }
14253 
14254 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14255 				hda_nid_t nid, unsigned int chs)
14256 {
14257 	char name[32];
14258 	snprintf(name, sizeof(name), "%s Playback Switch", pfx);
14259 	return add_control(codec->spec, ALC_CTL_WIDGET_MUTE, name,
14260 			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14261 }
14262 
14263 /* add playback controls from the parsed DAC table */
14264 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14265 					     const struct auto_pin_cfg *cfg)
14266 {
14267 	struct alc_spec *spec = codec->spec;
14268 	static const char *chname[4] = {
14269 		"Front", "Surround", NULL /*CLFE*/, "Side"
14270 	};
14271 	hda_nid_t nid;
14272 	int i, err;
14273 
14274 	if (cfg->line_outs == 1) {
14275 		const char *pfx = NULL;
14276 		if (!cfg->hp_outs)
14277 			pfx = "Master";
14278 		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14279 			pfx = "Speaker";
14280 		if (pfx) {
14281 			nid = spec->multiout.dac_nids[0];
14282 			return alc861_create_out_sw(codec, pfx, nid, 3);
14283 		}
14284 	}
14285 
14286 	for (i = 0; i < cfg->line_outs; i++) {
14287 		nid = spec->multiout.dac_nids[i];
14288 		if (!nid)
14289 			continue;
14290 		if (i == 2) {
14291 			/* Center/LFE */
14292 			err = alc861_create_out_sw(codec, "Center", nid, 1);
14293 			if (err < 0)
14294 				return err;
14295 			err = alc861_create_out_sw(codec, "LFE", nid, 2);
14296 			if (err < 0)
14297 				return err;
14298 		} else {
14299 			err = alc861_create_out_sw(codec, chname[i], nid, 3);
14300 			if (err < 0)
14301 				return err;
14302 		}
14303 	}
14304 	return 0;
14305 }
14306 
14307 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14308 {
14309 	struct alc_spec *spec = codec->spec;
14310 	int err;
14311 	hda_nid_t nid;
14312 
14313 	if (!pin)
14314 		return 0;
14315 
14316 	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14317 		nid = alc861_look_for_dac(codec, pin);
14318 		if (nid) {
14319 			err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14320 			if (err < 0)
14321 				return err;
14322 			spec->multiout.hp_nid = nid;
14323 		}
14324 	}
14325 	return 0;
14326 }
14327 
14328 /* create playback/capture controls for input pins */
14329 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14330 						const struct auto_pin_cfg *cfg)
14331 {
14332 	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14333 }
14334 
14335 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14336 					      hda_nid_t nid,
14337 					      int pin_type, hda_nid_t dac)
14338 {
14339 	hda_nid_t mix, srcs[5];
14340 	int i, num;
14341 
14342 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14343 			    pin_type);
14344 	snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14345 			    AMP_OUT_UNMUTE);
14346 	if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14347 		return;
14348 	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14349 	if (num < 0)
14350 		return;
14351 	for (i = 0; i < num; i++) {
14352 		unsigned int mute;
14353 		if (srcs[i] == dac || srcs[i] == 0x15)
14354 			mute = AMP_IN_UNMUTE(i);
14355 		else
14356 			mute = AMP_IN_MUTE(i);
14357 		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14358 				    mute);
14359 	}
14360 }
14361 
14362 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14363 {
14364 	struct alc_spec *spec = codec->spec;
14365 	int i;
14366 
14367 	for (i = 0; i < spec->autocfg.line_outs; i++) {
14368 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
14369 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
14370 		if (nid)
14371 			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14372 							  spec->multiout.dac_nids[i]);
14373 	}
14374 }
14375 
14376 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14377 {
14378 	struct alc_spec *spec = codec->spec;
14379 
14380 	if (spec->autocfg.hp_outs)
14381 		alc861_auto_set_output_and_unmute(codec,
14382 						  spec->autocfg.hp_pins[0],
14383 						  PIN_HP,
14384 						  spec->multiout.hp_nid);
14385 	if (spec->autocfg.speaker_outs)
14386 		alc861_auto_set_output_and_unmute(codec,
14387 						  spec->autocfg.speaker_pins[0],
14388 						  PIN_OUT,
14389 						  spec->multiout.dac_nids[0]);
14390 }
14391 
14392 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14393 {
14394 	struct alc_spec *spec = codec->spec;
14395 	int i;
14396 
14397 	for (i = 0; i < AUTO_PIN_LAST; i++) {
14398 		hda_nid_t nid = spec->autocfg.input_pins[i];
14399 		if (nid >= 0x0c && nid <= 0x11)
14400 			alc_set_input_pin(codec, nid, i);
14401 	}
14402 }
14403 
14404 /* parse the BIOS configuration and set up the alc_spec */
14405 /* return 1 if successful, 0 if the proper config is not found,
14406  * or a negative error code
14407  */
14408 static int alc861_parse_auto_config(struct hda_codec *codec)
14409 {
14410 	struct alc_spec *spec = codec->spec;
14411 	int err;
14412 	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14413 
14414 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14415 					   alc861_ignore);
14416 	if (err < 0)
14417 		return err;
14418 	if (!spec->autocfg.line_outs)
14419 		return 0; /* can't find valid BIOS pin config */
14420 
14421 	err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14422 	if (err < 0)
14423 		return err;
14424 	err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14425 	if (err < 0)
14426 		return err;
14427 	err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14428 	if (err < 0)
14429 		return err;
14430 	err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
14431 	if (err < 0)
14432 		return err;
14433 
14434 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14435 
14436 	if (spec->autocfg.dig_outs)
14437 		spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14438 
14439 	if (spec->kctls.list)
14440 		add_mixer(spec, spec->kctls.list);
14441 
14442 	add_verb(spec, alc861_auto_init_verbs);
14443 
14444 	spec->num_mux_defs = 1;
14445 	spec->input_mux = &spec->private_imux[0];
14446 
14447 	spec->adc_nids = alc861_adc_nids;
14448 	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14449 	set_capture_mixer(codec);
14450 
14451 	alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14452 
14453 	return 1;
14454 }
14455 
14456 /* additional initialization for auto-configuration model */
14457 static void alc861_auto_init(struct hda_codec *codec)
14458 {
14459 	struct alc_spec *spec = codec->spec;
14460 	alc861_auto_init_multi_out(codec);
14461 	alc861_auto_init_hp_out(codec);
14462 	alc861_auto_init_analog_input(codec);
14463 	if (spec->unsol_event)
14464 		alc_inithook(codec);
14465 }
14466 
14467 #ifdef CONFIG_SND_HDA_POWER_SAVE
14468 static struct hda_amp_list alc861_loopbacks[] = {
14469 	{ 0x15, HDA_INPUT, 0 },
14470 	{ 0x15, HDA_INPUT, 1 },
14471 	{ 0x15, HDA_INPUT, 2 },
14472 	{ 0x15, HDA_INPUT, 3 },
14473 	{ } /* end */
14474 };
14475 #endif
14476 
14477 
14478 /*
14479  * configuration and preset
14480  */
14481 static const char *alc861_models[ALC861_MODEL_LAST] = {
14482 	[ALC861_3ST]		= "3stack",
14483 	[ALC660_3ST]		= "3stack-660",
14484 	[ALC861_3ST_DIG]	= "3stack-dig",
14485 	[ALC861_6ST_DIG]	= "6stack-dig",
14486 	[ALC861_UNIWILL_M31]	= "uniwill-m31",
14487 	[ALC861_TOSHIBA]	= "toshiba",
14488 	[ALC861_ASUS]		= "asus",
14489 	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
14490 	[ALC861_AUTO]		= "auto",
14491 };
14492 
14493 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14494 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14495 	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14496 	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14497 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14498 	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14499 	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14500 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14501 	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14502 	 *        Any other models that need this preset?
14503 	 */
14504 	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14505 	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14506 	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14507 	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14508 	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14509 	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14510 	/* FIXME: the below seems conflict */
14511 	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14512 	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14513 	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14514 	{}
14515 };
14516 
14517 static struct alc_config_preset alc861_presets[] = {
14518 	[ALC861_3ST] = {
14519 		.mixers = { alc861_3ST_mixer },
14520 		.init_verbs = { alc861_threestack_init_verbs },
14521 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14522 		.dac_nids = alc861_dac_nids,
14523 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14524 		.channel_mode = alc861_threestack_modes,
14525 		.need_dac_fix = 1,
14526 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14527 		.adc_nids = alc861_adc_nids,
14528 		.input_mux = &alc861_capture_source,
14529 	},
14530 	[ALC861_3ST_DIG] = {
14531 		.mixers = { alc861_base_mixer },
14532 		.init_verbs = { alc861_threestack_init_verbs },
14533 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14534 		.dac_nids = alc861_dac_nids,
14535 		.dig_out_nid = ALC861_DIGOUT_NID,
14536 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14537 		.channel_mode = alc861_threestack_modes,
14538 		.need_dac_fix = 1,
14539 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14540 		.adc_nids = alc861_adc_nids,
14541 		.input_mux = &alc861_capture_source,
14542 	},
14543 	[ALC861_6ST_DIG] = {
14544 		.mixers = { alc861_base_mixer },
14545 		.init_verbs = { alc861_base_init_verbs },
14546 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14547 		.dac_nids = alc861_dac_nids,
14548 		.dig_out_nid = ALC861_DIGOUT_NID,
14549 		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14550 		.channel_mode = alc861_8ch_modes,
14551 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14552 		.adc_nids = alc861_adc_nids,
14553 		.input_mux = &alc861_capture_source,
14554 	},
14555 	[ALC660_3ST] = {
14556 		.mixers = { alc861_3ST_mixer },
14557 		.init_verbs = { alc861_threestack_init_verbs },
14558 		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
14559 		.dac_nids = alc660_dac_nids,
14560 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14561 		.channel_mode = alc861_threestack_modes,
14562 		.need_dac_fix = 1,
14563 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14564 		.adc_nids = alc861_adc_nids,
14565 		.input_mux = &alc861_capture_source,
14566 	},
14567 	[ALC861_UNIWILL_M31] = {
14568 		.mixers = { alc861_uniwill_m31_mixer },
14569 		.init_verbs = { alc861_uniwill_m31_init_verbs },
14570 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14571 		.dac_nids = alc861_dac_nids,
14572 		.dig_out_nid = ALC861_DIGOUT_NID,
14573 		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14574 		.channel_mode = alc861_uniwill_m31_modes,
14575 		.need_dac_fix = 1,
14576 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14577 		.adc_nids = alc861_adc_nids,
14578 		.input_mux = &alc861_capture_source,
14579 	},
14580 	[ALC861_TOSHIBA] = {
14581 		.mixers = { alc861_toshiba_mixer },
14582 		.init_verbs = { alc861_base_init_verbs,
14583 				alc861_toshiba_init_verbs },
14584 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14585 		.dac_nids = alc861_dac_nids,
14586 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14587 		.channel_mode = alc883_3ST_2ch_modes,
14588 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14589 		.adc_nids = alc861_adc_nids,
14590 		.input_mux = &alc861_capture_source,
14591 		.unsol_event = alc861_toshiba_unsol_event,
14592 		.init_hook = alc861_toshiba_automute,
14593 	},
14594 	[ALC861_ASUS] = {
14595 		.mixers = { alc861_asus_mixer },
14596 		.init_verbs = { alc861_asus_init_verbs },
14597 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14598 		.dac_nids = alc861_dac_nids,
14599 		.dig_out_nid = ALC861_DIGOUT_NID,
14600 		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14601 		.channel_mode = alc861_asus_modes,
14602 		.need_dac_fix = 1,
14603 		.hp_nid = 0x06,
14604 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14605 		.adc_nids = alc861_adc_nids,
14606 		.input_mux = &alc861_capture_source,
14607 	},
14608 	[ALC861_ASUS_LAPTOP] = {
14609 		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14610 		.init_verbs = { alc861_asus_init_verbs,
14611 				alc861_asus_laptop_init_verbs },
14612 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
14613 		.dac_nids = alc861_dac_nids,
14614 		.dig_out_nid = ALC861_DIGOUT_NID,
14615 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14616 		.channel_mode = alc883_3ST_2ch_modes,
14617 		.need_dac_fix = 1,
14618 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14619 		.adc_nids = alc861_adc_nids,
14620 		.input_mux = &alc861_capture_source,
14621 	},
14622 };
14623 
14624 
14625 static int patch_alc861(struct hda_codec *codec)
14626 {
14627 	struct alc_spec *spec;
14628 	int board_config;
14629 	int err;
14630 
14631 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14632 	if (spec == NULL)
14633 		return -ENOMEM;
14634 
14635 	codec->spec = spec;
14636 
14637         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14638 						  alc861_models,
14639 						  alc861_cfg_tbl);
14640 
14641 	if (board_config < 0) {
14642 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14643 		       codec->chip_name);
14644 		board_config = ALC861_AUTO;
14645 	}
14646 
14647 	if (board_config == ALC861_AUTO) {
14648 		/* automatic parse from the BIOS config */
14649 		err = alc861_parse_auto_config(codec);
14650 		if (err < 0) {
14651 			alc_free(codec);
14652 			return err;
14653 		} else if (!err) {
14654 			printk(KERN_INFO
14655 			       "hda_codec: Cannot set up configuration "
14656 			       "from BIOS.  Using base mode...\n");
14657 		   board_config = ALC861_3ST_DIG;
14658 		}
14659 	}
14660 
14661 	err = snd_hda_attach_beep_device(codec, 0x23);
14662 	if (err < 0) {
14663 		alc_free(codec);
14664 		return err;
14665 	}
14666 
14667 	if (board_config != ALC861_AUTO)
14668 		setup_preset(codec, &alc861_presets[board_config]);
14669 
14670 	spec->stream_analog_playback = &alc861_pcm_analog_playback;
14671 	spec->stream_analog_capture = &alc861_pcm_analog_capture;
14672 
14673 	spec->stream_digital_playback = &alc861_pcm_digital_playback;
14674 	spec->stream_digital_capture = &alc861_pcm_digital_capture;
14675 
14676 	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14677 
14678 	spec->vmaster_nid = 0x03;
14679 
14680 	codec->patch_ops = alc_patch_ops;
14681 	if (board_config == ALC861_AUTO)
14682 		spec->init_hook = alc861_auto_init;
14683 #ifdef CONFIG_SND_HDA_POWER_SAVE
14684 	if (!spec->loopback.amplist)
14685 		spec->loopback.amplist = alc861_loopbacks;
14686 #endif
14687 	codec->proc_widget_hook = print_realtek_coef;
14688 
14689 	return 0;
14690 }
14691 
14692 /*
14693  * ALC861-VD support
14694  *
14695  * Based on ALC882
14696  *
14697  * In addition, an independent DAC
14698  */
14699 #define ALC861VD_DIGOUT_NID	0x06
14700 
14701 static hda_nid_t alc861vd_dac_nids[4] = {
14702 	/* front, surr, clfe, side surr */
14703 	0x02, 0x03, 0x04, 0x05
14704 };
14705 
14706 /* dac_nids for ALC660vd are in a different order - according to
14707  * Realtek's driver.
14708  * This should probably result in a different mixer for 6stack models
14709  * of ALC660vd codecs, but for now there is only 3stack mixer
14710  * - and it is the same as in 861vd.
14711  * adc_nids in ALC660vd are (is) the same as in 861vd
14712  */
14713 static hda_nid_t alc660vd_dac_nids[3] = {
14714 	/* front, rear, clfe, rear_surr */
14715 	0x02, 0x04, 0x03
14716 };
14717 
14718 static hda_nid_t alc861vd_adc_nids[1] = {
14719 	/* ADC0 */
14720 	0x09,
14721 };
14722 
14723 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14724 
14725 /* input MUX */
14726 /* FIXME: should be a matrix-type input source selection */
14727 static struct hda_input_mux alc861vd_capture_source = {
14728 	.num_items = 4,
14729 	.items = {
14730 		{ "Mic", 0x0 },
14731 		{ "Front Mic", 0x1 },
14732 		{ "Line", 0x2 },
14733 		{ "CD", 0x4 },
14734 	},
14735 };
14736 
14737 static struct hda_input_mux alc861vd_dallas_capture_source = {
14738 	.num_items = 2,
14739 	.items = {
14740 		{ "Ext Mic", 0x0 },
14741 		{ "Int Mic", 0x1 },
14742 	},
14743 };
14744 
14745 static struct hda_input_mux alc861vd_hp_capture_source = {
14746 	.num_items = 2,
14747 	.items = {
14748 		{ "Front Mic", 0x0 },
14749 		{ "ATAPI Mic", 0x1 },
14750 	},
14751 };
14752 
14753 /*
14754  * 2ch mode
14755  */
14756 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14757 	{ 2, NULL }
14758 };
14759 
14760 /*
14761  * 6ch mode
14762  */
14763 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14764 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14765 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14766 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14767 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14768 	{ } /* end */
14769 };
14770 
14771 /*
14772  * 8ch mode
14773  */
14774 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14775 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14776 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14777 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14778 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14779 	{ } /* end */
14780 };
14781 
14782 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14783 	{ 6, alc861vd_6stack_ch6_init },
14784 	{ 8, alc861vd_6stack_ch8_init },
14785 };
14786 
14787 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14788 	{
14789 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14790 		.name = "Channel Mode",
14791 		.info = alc_ch_mode_info,
14792 		.get = alc_ch_mode_get,
14793 		.put = alc_ch_mode_put,
14794 	},
14795 	{ } /* end */
14796 };
14797 
14798 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14799  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14800  */
14801 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14802 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14803 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14804 
14805 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14806 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14807 
14808 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14809 				HDA_OUTPUT),
14810 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14811 				HDA_OUTPUT),
14812 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14813 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14814 
14815 	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14816 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14817 
14818 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14819 
14820 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14821 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14822 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14823 
14824 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14825 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14826 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14827 
14828 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14829 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14830 
14831 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14832 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14833 
14834 	{ } /* end */
14835 };
14836 
14837 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14838 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14839 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14840 
14841 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14842 
14843 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14844 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14845 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14846 
14847 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14848 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14849 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14850 
14851 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14852 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14853 
14854 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14855 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14856 
14857 	{ } /* end */
14858 };
14859 
14860 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14861 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14862 	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14863 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14864 
14865 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14866 
14867 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14868 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14869 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14870 
14871 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14872 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14873 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14874 
14875 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14876 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14877 
14878 	{ } /* end */
14879 };
14880 
14881 /* Pin assignment: Speaker=0x14, HP = 0x15,
14882  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14883  */
14884 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14885 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14886 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14887 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14888 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14889 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14890 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14891 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14892 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14893 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14894 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14895 	{ } /* end */
14896 };
14897 
14898 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14899  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14900  */
14901 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14902 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14903 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14904 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14905 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14906 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14907 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14908 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14909 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14910 
14911 	{ } /* end */
14912 };
14913 
14914 /*
14915  * generic initialization of ADC, input mixers and output mixers
14916  */
14917 static struct hda_verb alc861vd_volume_init_verbs[] = {
14918 	/*
14919 	 * Unmute ADC0 and set the default input to mic-in
14920 	 */
14921 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14922 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14923 
14924 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14925 	 * the analog-loopback mixer widget
14926 	 */
14927 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14928 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14929 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14930 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14931 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14932 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14933 
14934 	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14935 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14936 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14937 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14938 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14939 
14940 	/*
14941 	 * Set up output mixers (0x02 - 0x05)
14942 	 */
14943 	/* set vol=0 to output mixers */
14944 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14945 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14946 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14947 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14948 
14949 	/* set up input amps for analog loopback */
14950 	/* Amp Indices: DAC = 0, mixer = 1 */
14951 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14952 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14953 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14954 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14955 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14956 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14957 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14958 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14959 
14960 	{ }
14961 };
14962 
14963 /*
14964  * 3-stack pin configuration:
14965  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14966  */
14967 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14968 	/*
14969 	 * Set pin mode and muting
14970 	 */
14971 	/* set front pin widgets 0x14 for output */
14972 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14973 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14974 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14975 
14976 	/* Mic (rear) pin: input vref at 80% */
14977 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14978 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14979 	/* Front Mic pin: input vref at 80% */
14980 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14981 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14982 	/* Line In pin: input */
14983 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14984 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14985 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
14986 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14987 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14988 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14989 	/* CD pin widget for input */
14990 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14991 
14992 	{ }
14993 };
14994 
14995 /*
14996  * 6-stack pin configuration:
14997  */
14998 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14999 	/*
15000 	 * Set pin mode and muting
15001 	 */
15002 	/* set front pin widgets 0x14 for output */
15003 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15004 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15005 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15006 
15007 	/* Rear Pin: output 1 (0x0d) */
15008 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15009 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15010 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15011 	/* CLFE Pin: output 2 (0x0e) */
15012 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15013 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15014 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15015 	/* Side Pin: output 3 (0x0f) */
15016 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15017 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15018 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15019 
15020 	/* Mic (rear) pin: input vref at 80% */
15021 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15022 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15023 	/* Front Mic pin: input vref at 80% */
15024 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15025 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15026 	/* Line In pin: input */
15027 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15028 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15029 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
15030 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15031 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15032 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15033 	/* CD pin widget for input */
15034 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15035 
15036 	{ }
15037 };
15038 
15039 static struct hda_verb alc861vd_eapd_verbs[] = {
15040 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15041 	{ }
15042 };
15043 
15044 static struct hda_verb alc660vd_eapd_verbs[] = {
15045 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15046 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15047 	{ }
15048 };
15049 
15050 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15051 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15052 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15053 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15054 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15055 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15056 	{}
15057 };
15058 
15059 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15060 {
15061 	unsigned int present;
15062 	unsigned char bits;
15063 
15064 	present = snd_hda_codec_read(codec, 0x18, 0,
15065 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15066 	bits = present ? HDA_AMP_MUTE : 0;
15067 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15068 				 HDA_AMP_MUTE, bits);
15069 }
15070 
15071 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15072 {
15073 	struct alc_spec *spec = codec->spec;
15074 	spec->autocfg.hp_pins[0] = 0x1b;
15075 	spec->autocfg.speaker_pins[0] = 0x14;
15076 }
15077 
15078 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15079 {
15080 	alc_automute_amp(codec);
15081 	alc861vd_lenovo_mic_automute(codec);
15082 }
15083 
15084 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15085 					unsigned int res)
15086 {
15087 	switch (res >> 26) {
15088 	case ALC880_MIC_EVENT:
15089 		alc861vd_lenovo_mic_automute(codec);
15090 		break;
15091 	default:
15092 		alc_automute_amp_unsol_event(codec, res);
15093 		break;
15094 	}
15095 }
15096 
15097 static struct hda_verb alc861vd_dallas_verbs[] = {
15098 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15099 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15100 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15101 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15102 
15103 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15104 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15105 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15106 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15107 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15108 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15109 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15110 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15111 
15112 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15113 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15114 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15115 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15116 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15117 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15118 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15119 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15120 
15121 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15122 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15123 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15124 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15125 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15126 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15127 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15128 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15129 
15130 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15131 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15132 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15133 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15134 
15135 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15136 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15137 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15138 
15139 	{ } /* end */
15140 };
15141 
15142 /* toggle speaker-output according to the hp-jack state */
15143 static void alc861vd_dallas_setup(struct hda_codec *codec)
15144 {
15145 	struct alc_spec *spec = codec->spec;
15146 
15147 	spec->autocfg.hp_pins[0] = 0x15;
15148 	spec->autocfg.speaker_pins[0] = 0x14;
15149 }
15150 
15151 #ifdef CONFIG_SND_HDA_POWER_SAVE
15152 #define alc861vd_loopbacks	alc880_loopbacks
15153 #endif
15154 
15155 /* pcm configuration: identical with ALC880 */
15156 #define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
15157 #define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
15158 #define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
15159 #define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
15160 
15161 /*
15162  * configuration and preset
15163  */
15164 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15165 	[ALC660VD_3ST]		= "3stack-660",
15166 	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
15167 	[ALC660VD_ASUS_V1S]	= "asus-v1s",
15168 	[ALC861VD_3ST]		= "3stack",
15169 	[ALC861VD_3ST_DIG]	= "3stack-digout",
15170 	[ALC861VD_6ST_DIG]	= "6stack-digout",
15171 	[ALC861VD_LENOVO]	= "lenovo",
15172 	[ALC861VD_DALLAS]	= "dallas",
15173 	[ALC861VD_HP]		= "hp",
15174 	[ALC861VD_AUTO]		= "auto",
15175 };
15176 
15177 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15178 	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15179 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15180 	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15181 	/*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15182 	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15183 	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15184 	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15185 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15186 	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15187 	SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15188 	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15189 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15190 	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15191 	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15192 	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15193 	{}
15194 };
15195 
15196 static struct alc_config_preset alc861vd_presets[] = {
15197 	[ALC660VD_3ST] = {
15198 		.mixers = { alc861vd_3st_mixer },
15199 		.init_verbs = { alc861vd_volume_init_verbs,
15200 				 alc861vd_3stack_init_verbs },
15201 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15202 		.dac_nids = alc660vd_dac_nids,
15203 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15204 		.channel_mode = alc861vd_3stack_2ch_modes,
15205 		.input_mux = &alc861vd_capture_source,
15206 	},
15207 	[ALC660VD_3ST_DIG] = {
15208 		.mixers = { alc861vd_3st_mixer },
15209 		.init_verbs = { alc861vd_volume_init_verbs,
15210 				 alc861vd_3stack_init_verbs },
15211 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15212 		.dac_nids = alc660vd_dac_nids,
15213 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15214 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15215 		.channel_mode = alc861vd_3stack_2ch_modes,
15216 		.input_mux = &alc861vd_capture_source,
15217 	},
15218 	[ALC861VD_3ST] = {
15219 		.mixers = { alc861vd_3st_mixer },
15220 		.init_verbs = { alc861vd_volume_init_verbs,
15221 				 alc861vd_3stack_init_verbs },
15222 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15223 		.dac_nids = alc861vd_dac_nids,
15224 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15225 		.channel_mode = alc861vd_3stack_2ch_modes,
15226 		.input_mux = &alc861vd_capture_source,
15227 	},
15228 	[ALC861VD_3ST_DIG] = {
15229 		.mixers = { alc861vd_3st_mixer },
15230 		.init_verbs = { alc861vd_volume_init_verbs,
15231 		 		 alc861vd_3stack_init_verbs },
15232 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15233 		.dac_nids = alc861vd_dac_nids,
15234 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15235 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15236 		.channel_mode = alc861vd_3stack_2ch_modes,
15237 		.input_mux = &alc861vd_capture_source,
15238 	},
15239 	[ALC861VD_6ST_DIG] = {
15240 		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15241 		.init_verbs = { alc861vd_volume_init_verbs,
15242 				alc861vd_6stack_init_verbs },
15243 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15244 		.dac_nids = alc861vd_dac_nids,
15245 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15246 		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15247 		.channel_mode = alc861vd_6stack_modes,
15248 		.input_mux = &alc861vd_capture_source,
15249 	},
15250 	[ALC861VD_LENOVO] = {
15251 		.mixers = { alc861vd_lenovo_mixer },
15252 		.init_verbs = { alc861vd_volume_init_verbs,
15253 				alc861vd_3stack_init_verbs,
15254 				alc861vd_eapd_verbs,
15255 				alc861vd_lenovo_unsol_verbs },
15256 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15257 		.dac_nids = alc660vd_dac_nids,
15258 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15259 		.channel_mode = alc861vd_3stack_2ch_modes,
15260 		.input_mux = &alc861vd_capture_source,
15261 		.unsol_event = alc861vd_lenovo_unsol_event,
15262 		.setup = alc861vd_lenovo_setup,
15263 		.init_hook = alc861vd_lenovo_init_hook,
15264 	},
15265 	[ALC861VD_DALLAS] = {
15266 		.mixers = { alc861vd_dallas_mixer },
15267 		.init_verbs = { alc861vd_dallas_verbs },
15268 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15269 		.dac_nids = alc861vd_dac_nids,
15270 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15271 		.channel_mode = alc861vd_3stack_2ch_modes,
15272 		.input_mux = &alc861vd_dallas_capture_source,
15273 		.unsol_event = alc_automute_amp_unsol_event,
15274 		.setup = alc861vd_dallas_setup,
15275 		.init_hook = alc_automute_amp,
15276 	},
15277 	[ALC861VD_HP] = {
15278 		.mixers = { alc861vd_hp_mixer },
15279 		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15280 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15281 		.dac_nids = alc861vd_dac_nids,
15282 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15283 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15284 		.channel_mode = alc861vd_3stack_2ch_modes,
15285 		.input_mux = &alc861vd_hp_capture_source,
15286 		.unsol_event = alc_automute_amp_unsol_event,
15287 		.setup = alc861vd_dallas_setup,
15288 		.init_hook = alc_automute_amp,
15289 	},
15290 	[ALC660VD_ASUS_V1S] = {
15291 		.mixers = { alc861vd_lenovo_mixer },
15292 		.init_verbs = { alc861vd_volume_init_verbs,
15293 				alc861vd_3stack_init_verbs,
15294 				alc861vd_eapd_verbs,
15295 				alc861vd_lenovo_unsol_verbs },
15296 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15297 		.dac_nids = alc660vd_dac_nids,
15298 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15299 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15300 		.channel_mode = alc861vd_3stack_2ch_modes,
15301 		.input_mux = &alc861vd_capture_source,
15302 		.unsol_event = alc861vd_lenovo_unsol_event,
15303 		.setup = alc861vd_lenovo_setup,
15304 		.init_hook = alc861vd_lenovo_init_hook,
15305 	},
15306 };
15307 
15308 /*
15309  * BIOS auto configuration
15310  */
15311 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15312 						const struct auto_pin_cfg *cfg)
15313 {
15314 	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
15315 }
15316 
15317 
15318 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15319 				hda_nid_t nid, int pin_type, int dac_idx)
15320 {
15321 	alc_set_pin_output(codec, nid, pin_type);
15322 }
15323 
15324 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15325 {
15326 	struct alc_spec *spec = codec->spec;
15327 	int i;
15328 
15329 	for (i = 0; i <= HDA_SIDE; i++) {
15330 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
15331 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
15332 		if (nid)
15333 			alc861vd_auto_set_output_and_unmute(codec, nid,
15334 							    pin_type, i);
15335 	}
15336 }
15337 
15338 
15339 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15340 {
15341 	struct alc_spec *spec = codec->spec;
15342 	hda_nid_t pin;
15343 
15344 	pin = spec->autocfg.hp_pins[0];
15345 	if (pin) /* connect to front and use dac 0 */
15346 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15347 	pin = spec->autocfg.speaker_pins[0];
15348 	if (pin)
15349 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15350 }
15351 
15352 #define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
15353 
15354 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15355 {
15356 	struct alc_spec *spec = codec->spec;
15357 	int i;
15358 
15359 	for (i = 0; i < AUTO_PIN_LAST; i++) {
15360 		hda_nid_t nid = spec->autocfg.input_pins[i];
15361 		if (alc_is_input_pin(codec, nid)) {
15362 			alc_set_input_pin(codec, nid, i);
15363 			if (nid != ALC861VD_PIN_CD_NID &&
15364 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15365 				snd_hda_codec_write(codec, nid, 0,
15366 						AC_VERB_SET_AMP_GAIN_MUTE,
15367 						AMP_OUT_MUTE);
15368 		}
15369 	}
15370 }
15371 
15372 #define alc861vd_auto_init_input_src	alc882_auto_init_input_src
15373 
15374 #define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
15375 #define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
15376 
15377 /* add playback controls from the parsed DAC table */
15378 /* Based on ALC880 version. But ALC861VD has separate,
15379  * different NIDs for mute/unmute switch and volume control */
15380 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15381 					     const struct auto_pin_cfg *cfg)
15382 {
15383 	char name[32];
15384 	static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15385 	hda_nid_t nid_v, nid_s;
15386 	int i, err;
15387 
15388 	for (i = 0; i < cfg->line_outs; i++) {
15389 		if (!spec->multiout.dac_nids[i])
15390 			continue;
15391 		nid_v = alc861vd_idx_to_mixer_vol(
15392 				alc880_dac_to_idx(
15393 					spec->multiout.dac_nids[i]));
15394 		nid_s = alc861vd_idx_to_mixer_switch(
15395 				alc880_dac_to_idx(
15396 					spec->multiout.dac_nids[i]));
15397 
15398 		if (i == 2) {
15399 			/* Center/LFE */
15400 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
15401 					  "Center Playback Volume",
15402 					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15403 							      HDA_OUTPUT));
15404 			if (err < 0)
15405 				return err;
15406 			err = add_control(spec, ALC_CTL_WIDGET_VOL,
15407 					  "LFE Playback Volume",
15408 					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15409 							      HDA_OUTPUT));
15410 			if (err < 0)
15411 				return err;
15412 			err = add_control(spec, ALC_CTL_BIND_MUTE,
15413 					  "Center Playback Switch",
15414 					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15415 							      HDA_INPUT));
15416 			if (err < 0)
15417 				return err;
15418 			err = add_control(spec, ALC_CTL_BIND_MUTE,
15419 					  "LFE Playback Switch",
15420 					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15421 							      HDA_INPUT));
15422 			if (err < 0)
15423 				return err;
15424 		} else {
15425 			const char *pfx;
15426 			if (cfg->line_outs == 1 &&
15427 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
15428 				if (!cfg->hp_pins)
15429 					pfx = "Speaker";
15430 				else
15431 					pfx = "PCM";
15432 			} else
15433 				pfx = chname[i];
15434 			sprintf(name, "%s Playback Volume", pfx);
15435 			err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15436 					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15437 							      HDA_OUTPUT));
15438 			if (err < 0)
15439 				return err;
15440 			if (cfg->line_outs == 1 &&
15441 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15442 				pfx = "Speaker";
15443 			sprintf(name, "%s Playback Switch", pfx);
15444 			err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15445 					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15446 							      HDA_INPUT));
15447 			if (err < 0)
15448 				return err;
15449 		}
15450 	}
15451 	return 0;
15452 }
15453 
15454 /* add playback controls for speaker and HP outputs */
15455 /* Based on ALC880 version. But ALC861VD has separate,
15456  * different NIDs for mute/unmute switch and volume control */
15457 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15458 					hda_nid_t pin, const char *pfx)
15459 {
15460 	hda_nid_t nid_v, nid_s;
15461 	int err;
15462 	char name[32];
15463 
15464 	if (!pin)
15465 		return 0;
15466 
15467 	if (alc880_is_fixed_pin(pin)) {
15468 		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15469 		/* specify the DAC as the extra output */
15470 		if (!spec->multiout.hp_nid)
15471 			spec->multiout.hp_nid = nid_v;
15472 		else
15473 			spec->multiout.extra_out_nid[0] = nid_v;
15474 		/* control HP volume/switch on the output mixer amp */
15475 		nid_v = alc861vd_idx_to_mixer_vol(
15476 				alc880_fixed_pin_idx(pin));
15477 		nid_s = alc861vd_idx_to_mixer_switch(
15478 				alc880_fixed_pin_idx(pin));
15479 
15480 		sprintf(name, "%s Playback Volume", pfx);
15481 		err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15482 				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15483 		if (err < 0)
15484 			return err;
15485 		sprintf(name, "%s Playback Switch", pfx);
15486 		err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15487 				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15488 		if (err < 0)
15489 			return err;
15490 	} else if (alc880_is_multi_pin(pin)) {
15491 		/* set manual connection */
15492 		/* we have only a switch on HP-out PIN */
15493 		sprintf(name, "%s Playback Switch", pfx);
15494 		err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15495 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15496 		if (err < 0)
15497 			return err;
15498 	}
15499 	return 0;
15500 }
15501 
15502 /* parse the BIOS configuration and set up the alc_spec
15503  * return 1 if successful, 0 if the proper config is not found,
15504  * or a negative error code
15505  * Based on ALC880 version - had to change it to override
15506  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15507 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15508 {
15509 	struct alc_spec *spec = codec->spec;
15510 	int err;
15511 	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15512 
15513 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15514 					   alc861vd_ignore);
15515 	if (err < 0)
15516 		return err;
15517 	if (!spec->autocfg.line_outs)
15518 		return 0; /* can't find valid BIOS pin config */
15519 
15520 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15521 	if (err < 0)
15522 		return err;
15523 	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15524 	if (err < 0)
15525 		return err;
15526 	err = alc861vd_auto_create_extra_out(spec,
15527 					     spec->autocfg.speaker_pins[0],
15528 					     "Speaker");
15529 	if (err < 0)
15530 		return err;
15531 	err = alc861vd_auto_create_extra_out(spec,
15532 					     spec->autocfg.hp_pins[0],
15533 					     "Headphone");
15534 	if (err < 0)
15535 		return err;
15536 	err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
15537 	if (err < 0)
15538 		return err;
15539 
15540 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15541 
15542 	if (spec->autocfg.dig_outs)
15543 		spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15544 
15545 	if (spec->kctls.list)
15546 		add_mixer(spec, spec->kctls.list);
15547 
15548 	add_verb(spec, alc861vd_volume_init_verbs);
15549 
15550 	spec->num_mux_defs = 1;
15551 	spec->input_mux = &spec->private_imux[0];
15552 
15553 	err = alc_auto_add_mic_boost(codec);
15554 	if (err < 0)
15555 		return err;
15556 
15557 	alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15558 
15559 	return 1;
15560 }
15561 
15562 /* additional initialization for auto-configuration model */
15563 static void alc861vd_auto_init(struct hda_codec *codec)
15564 {
15565 	struct alc_spec *spec = codec->spec;
15566 	alc861vd_auto_init_multi_out(codec);
15567 	alc861vd_auto_init_hp_out(codec);
15568 	alc861vd_auto_init_analog_input(codec);
15569 	alc861vd_auto_init_input_src(codec);
15570 	if (spec->unsol_event)
15571 		alc_inithook(codec);
15572 }
15573 
15574 enum {
15575 	ALC660VD_FIX_ASUS_GPIO1
15576 };
15577 
15578 /* reset GPIO1 */
15579 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
15580 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
15581 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
15582 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
15583 	{ }
15584 };
15585 
15586 static const struct alc_fixup alc861vd_fixups[] = {
15587 	[ALC660VD_FIX_ASUS_GPIO1] = {
15588 		.verbs = alc660vd_fix_asus_gpio1_verbs,
15589 	},
15590 };
15591 
15592 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
15593 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
15594 	{}
15595 };
15596 
15597 static int patch_alc861vd(struct hda_codec *codec)
15598 {
15599 	struct alc_spec *spec;
15600 	int err, board_config;
15601 
15602 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15603 	if (spec == NULL)
15604 		return -ENOMEM;
15605 
15606 	codec->spec = spec;
15607 
15608 	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15609 						  alc861vd_models,
15610 						  alc861vd_cfg_tbl);
15611 
15612 	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15613 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15614 		       codec->chip_name);
15615 		board_config = ALC861VD_AUTO;
15616 	}
15617 
15618 	alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
15619 
15620 	if (board_config == ALC861VD_AUTO) {
15621 		/* automatic parse from the BIOS config */
15622 		err = alc861vd_parse_auto_config(codec);
15623 		if (err < 0) {
15624 			alc_free(codec);
15625 			return err;
15626 		} else if (!err) {
15627 			printk(KERN_INFO
15628 			       "hda_codec: Cannot set up configuration "
15629 			       "from BIOS.  Using base mode...\n");
15630 			board_config = ALC861VD_3ST;
15631 		}
15632 	}
15633 
15634 	err = snd_hda_attach_beep_device(codec, 0x23);
15635 	if (err < 0) {
15636 		alc_free(codec);
15637 		return err;
15638 	}
15639 
15640 	if (board_config != ALC861VD_AUTO)
15641 		setup_preset(codec, &alc861vd_presets[board_config]);
15642 
15643 	if (codec->vendor_id == 0x10ec0660) {
15644 		/* always turn on EAPD */
15645 		add_verb(spec, alc660vd_eapd_verbs);
15646 	}
15647 
15648 	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15649 	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15650 
15651 	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15652 	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15653 
15654 	if (!spec->adc_nids) {
15655 		spec->adc_nids = alc861vd_adc_nids;
15656 		spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15657 	}
15658 	if (!spec->capsrc_nids)
15659 		spec->capsrc_nids = alc861vd_capsrc_nids;
15660 
15661 	set_capture_mixer(codec);
15662 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15663 
15664 	spec->vmaster_nid = 0x02;
15665 
15666 	codec->patch_ops = alc_patch_ops;
15667 
15668 	if (board_config == ALC861VD_AUTO)
15669 		spec->init_hook = alc861vd_auto_init;
15670 #ifdef CONFIG_SND_HDA_POWER_SAVE
15671 	if (!spec->loopback.amplist)
15672 		spec->loopback.amplist = alc861vd_loopbacks;
15673 #endif
15674 	codec->proc_widget_hook = print_realtek_coef;
15675 
15676 	return 0;
15677 }
15678 
15679 /*
15680  * ALC662 support
15681  *
15682  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15683  * configuration.  Each pin widget can choose any input DACs and a mixer.
15684  * Each ADC is connected from a mixer of all inputs.  This makes possible
15685  * 6-channel independent captures.
15686  *
15687  * In addition, an independent DAC for the multi-playback (not used in this
15688  * driver yet).
15689  */
15690 #define ALC662_DIGOUT_NID	0x06
15691 #define ALC662_DIGIN_NID	0x0a
15692 
15693 static hda_nid_t alc662_dac_nids[4] = {
15694 	/* front, rear, clfe, rear_surr */
15695 	0x02, 0x03, 0x04
15696 };
15697 
15698 static hda_nid_t alc272_dac_nids[2] = {
15699 	0x02, 0x03
15700 };
15701 
15702 static hda_nid_t alc662_adc_nids[2] = {
15703 	/* ADC1-2 */
15704 	0x09, 0x08
15705 };
15706 
15707 static hda_nid_t alc272_adc_nids[1] = {
15708 	/* ADC1-2 */
15709 	0x08,
15710 };
15711 
15712 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
15713 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15714 
15715 
15716 /* input MUX */
15717 /* FIXME: should be a matrix-type input source selection */
15718 static struct hda_input_mux alc662_capture_source = {
15719 	.num_items = 4,
15720 	.items = {
15721 		{ "Mic", 0x0 },
15722 		{ "Front Mic", 0x1 },
15723 		{ "Line", 0x2 },
15724 		{ "CD", 0x4 },
15725 	},
15726 };
15727 
15728 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15729 	.num_items = 2,
15730 	.items = {
15731 		{ "Mic", 0x1 },
15732 		{ "Line", 0x2 },
15733 	},
15734 };
15735 
15736 static struct hda_input_mux alc663_capture_source = {
15737 	.num_items = 3,
15738 	.items = {
15739 		{ "Mic", 0x0 },
15740 		{ "Front Mic", 0x1 },
15741 		{ "Line", 0x2 },
15742 	},
15743 };
15744 
15745 #if 0 /* set to 1 for testing other input sources below */
15746 static struct hda_input_mux alc272_nc10_capture_source = {
15747 	.num_items = 16,
15748 	.items = {
15749 		{ "Autoselect Mic", 0x0 },
15750 		{ "Internal Mic", 0x1 },
15751 		{ "In-0x02", 0x2 },
15752 		{ "In-0x03", 0x3 },
15753 		{ "In-0x04", 0x4 },
15754 		{ "In-0x05", 0x5 },
15755 		{ "In-0x06", 0x6 },
15756 		{ "In-0x07", 0x7 },
15757 		{ "In-0x08", 0x8 },
15758 		{ "In-0x09", 0x9 },
15759 		{ "In-0x0a", 0x0a },
15760 		{ "In-0x0b", 0x0b },
15761 		{ "In-0x0c", 0x0c },
15762 		{ "In-0x0d", 0x0d },
15763 		{ "In-0x0e", 0x0e },
15764 		{ "In-0x0f", 0x0f },
15765 	},
15766 };
15767 #endif
15768 
15769 /*
15770  * 2ch mode
15771  */
15772 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15773 	{ 2, NULL }
15774 };
15775 
15776 /*
15777  * 2ch mode
15778  */
15779 static struct hda_verb alc662_3ST_ch2_init[] = {
15780 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15781 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15782 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15783 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15784 	{ } /* end */
15785 };
15786 
15787 /*
15788  * 6ch mode
15789  */
15790 static struct hda_verb alc662_3ST_ch6_init[] = {
15791 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15792 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15793 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15794 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15795 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15796 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15797 	{ } /* end */
15798 };
15799 
15800 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15801 	{ 2, alc662_3ST_ch2_init },
15802 	{ 6, alc662_3ST_ch6_init },
15803 };
15804 
15805 /*
15806  * 2ch mode
15807  */
15808 static struct hda_verb alc662_sixstack_ch6_init[] = {
15809 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15810 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15811 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15812 	{ } /* end */
15813 };
15814 
15815 /*
15816  * 6ch mode
15817  */
15818 static struct hda_verb alc662_sixstack_ch8_init[] = {
15819 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15820 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15821 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15822 	{ } /* end */
15823 };
15824 
15825 static struct hda_channel_mode alc662_5stack_modes[2] = {
15826 	{ 2, alc662_sixstack_ch6_init },
15827 	{ 6, alc662_sixstack_ch8_init },
15828 };
15829 
15830 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15831  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15832  */
15833 
15834 static struct snd_kcontrol_new alc662_base_mixer[] = {
15835 	/* output mixer control */
15836 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15837 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15838 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15839 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15840 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15841 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15842 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15843 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15844 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15845 
15846 	/*Input mixer control */
15847 	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15848 	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15849 	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15850 	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15851 	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15852 	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15853 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15854 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15855 	{ } /* end */
15856 };
15857 
15858 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15859 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15860 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15861 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15862 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15863 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15864 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15865 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15866 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15867 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15868 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15869 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15870 	{ } /* end */
15871 };
15872 
15873 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15874 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15875 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15876 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15877 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15878 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15879 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15880 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15881 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15882 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15883 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15884 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15885 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15886 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15887 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15888 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15889 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15890 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15891 	{ } /* end */
15892 };
15893 
15894 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15895 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15896 	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15897 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15898 	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15899 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15900 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15901 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15902 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15903 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15904 	{ } /* end */
15905 };
15906 
15907 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15908 	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15909 	ALC262_HIPPO_MASTER_SWITCH,
15910 
15911 	HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15912 	HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15913 	HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15914 
15915 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15916 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15917 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15918 	{ } /* end */
15919 };
15920 
15921 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15922 	ALC262_HIPPO_MASTER_SWITCH,
15923 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15924 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15925 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15926 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15927 	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15928 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15929 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15930 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15931 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15932 	{ } /* end */
15933 };
15934 
15935 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15936 	.ops = &snd_hda_bind_vol,
15937 	.values = {
15938 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15939 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15940 		0
15941 	},
15942 };
15943 
15944 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15945 	.ops = &snd_hda_bind_sw,
15946 	.values = {
15947 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15948 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15949 		0
15950 	},
15951 };
15952 
15953 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15954 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15955 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15956 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15957 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15958 	{ } /* end */
15959 };
15960 
15961 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15962 	.ops = &snd_hda_bind_sw,
15963 	.values = {
15964 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15965 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15966 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15967 		0
15968 	},
15969 };
15970 
15971 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15972 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15973 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15974 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15975 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15976 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15977 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15978 
15979 	{ } /* end */
15980 };
15981 
15982 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15983 	.ops = &snd_hda_bind_sw,
15984 	.values = {
15985 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15986 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15987 		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15988 		0
15989 	},
15990 };
15991 
15992 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15993 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15994 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15995 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15996 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15997 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15998 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15999 	{ } /* end */
16000 };
16001 
16002 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16003 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16004 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16005 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16006 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16007 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16008 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16009 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16010 	{ } /* end */
16011 };
16012 
16013 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16014 	.ops = &snd_hda_bind_vol,
16015 	.values = {
16016 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16017 		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16018 		0
16019 	},
16020 };
16021 
16022 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16023 	.ops = &snd_hda_bind_sw,
16024 	.values = {
16025 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16026 		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16027 		0
16028 	},
16029 };
16030 
16031 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16032 	HDA_BIND_VOL("Master Playback Volume",
16033 				&alc663_asus_two_bind_master_vol),
16034 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16035 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16036 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16037 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16038 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16039 	{ } /* end */
16040 };
16041 
16042 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16043 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16044 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16045 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16046 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16047 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16048 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16049 	{ } /* end */
16050 };
16051 
16052 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16053 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16054 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16055 	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16056 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16057 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16058 
16059 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16060 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16061 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16062 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16063 	{ } /* end */
16064 };
16065 
16066 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16067 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16068 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16069 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16070 
16071 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16072 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16073 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16074 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16075 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16076 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16077 	{ } /* end */
16078 };
16079 
16080 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16081 	{
16082 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16083 		.name = "Channel Mode",
16084 		.info = alc_ch_mode_info,
16085 		.get = alc_ch_mode_get,
16086 		.put = alc_ch_mode_put,
16087 	},
16088 	{ } /* end */
16089 };
16090 
16091 static struct hda_verb alc662_init_verbs[] = {
16092 	/* ADC: mute amp left and right */
16093 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16094 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16095 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
16096 
16097 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16098 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16099 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16100 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16101 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16102 
16103 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16104 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16105 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16106 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16107 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16108 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16109 
16110 	/* Front Pin: output 0 (0x0c) */
16111 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16112 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16113 
16114 	/* Rear Pin: output 1 (0x0d) */
16115 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16116 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16117 
16118 	/* CLFE Pin: output 2 (0x0e) */
16119 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16120 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16121 
16122 	/* Mic (rear) pin: input vref at 80% */
16123 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16124 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16125 	/* Front Mic pin: input vref at 80% */
16126 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16127 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16128 	/* Line In pin: input */
16129 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16130 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16131 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16132 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16133 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16134 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16135 	/* CD pin widget for input */
16136 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16137 
16138 	/* FIXME: use matrix-type input source selection */
16139 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16140 	/* Input mixer */
16141 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16142 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16143 
16144 	/* always trun on EAPD */
16145 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16146 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16147 
16148 	{ }
16149 };
16150 
16151 static struct hda_verb alc662_sue_init_verbs[] = {
16152 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16153 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16154 	{}
16155 };
16156 
16157 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16158 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16159 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16160 	{}
16161 };
16162 
16163 /* Set Unsolicited Event*/
16164 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16165 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16166 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16167 	{}
16168 };
16169 
16170 /*
16171  * generic initialization of ADC, input mixers and output mixers
16172  */
16173 static struct hda_verb alc662_auto_init_verbs[] = {
16174 	/*
16175 	 * Unmute ADC and set the default input to mic-in
16176 	 */
16177 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16178 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16179 
16180 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16181 	 * mixer widget
16182 	 * Note: PASD motherboards uses the Line In 2 as the input for front
16183 	 * panel mic (mic 2)
16184 	 */
16185 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16186 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16187 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16188 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16189 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16190 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16191 
16192 	/*
16193 	 * Set up output mixers (0x0c - 0x0f)
16194 	 */
16195 	/* set vol=0 to output mixers */
16196 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16197 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16198 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16199 
16200 	/* set up input amps for analog loopback */
16201 	/* Amp Indices: DAC = 0, mixer = 1 */
16202 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16203 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16204 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16205 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16206 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16207 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16208 
16209 
16210 	/* FIXME: use matrix-type input source selection */
16211 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16212 	/* Input mixer */
16213 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16214 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16215 	{ }
16216 };
16217 
16218 /* additional verbs for ALC663 */
16219 static struct hda_verb alc663_auto_init_verbs[] = {
16220 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16221 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16222 	{ }
16223 };
16224 
16225 static struct hda_verb alc663_m51va_init_verbs[] = {
16226 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16227 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16228 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16229 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16230 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16231 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16232 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16233 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16234 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16235 	{}
16236 };
16237 
16238 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16239 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16240 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16241 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16242 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16243 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16244 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16245 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16246 	{}
16247 };
16248 
16249 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16250 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16251 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16252 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16253 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
16254 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16255 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16256 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16257 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16258 	{}
16259 };
16260 
16261 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16262 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16263 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16264 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16265 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16266 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16267 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16268 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16269 	{}
16270 };
16271 
16272 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16273 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16274 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16275 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16276 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
16277 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16278 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16279 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
16280 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16281 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16282 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16283 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16284 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16285 	{}
16286 };
16287 
16288 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16289 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16290 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16291 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16292 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16293 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16294 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16295 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16296 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16297 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16298 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16299 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16300 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16301 	{}
16302 };
16303 
16304 static struct hda_verb alc663_g71v_init_verbs[] = {
16305 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16306 	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16307 	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16308 
16309 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16310 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16311 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
16312 
16313 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16314 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16315 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16316 	{}
16317 };
16318 
16319 static struct hda_verb alc663_g50v_init_verbs[] = {
16320 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16321 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16322 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
16323 
16324 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16325 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16326 	{}
16327 };
16328 
16329 static struct hda_verb alc662_ecs_init_verbs[] = {
16330 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16331 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16332 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16333 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16334 	{}
16335 };
16336 
16337 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16338 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16339 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16340 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16341 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16342 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16343 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16344 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16345 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16346 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16347 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16348 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16349 	{}
16350 };
16351 
16352 static struct hda_verb alc272_dell_init_verbs[] = {
16353 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16354 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16355 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16356 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16357 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16358 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16359 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16360 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16361 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16362 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16363 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16364 	{}
16365 };
16366 
16367 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16368 	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16369 	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16370 	{ } /* end */
16371 };
16372 
16373 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16374 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16375 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16376 	{ } /* end */
16377 };
16378 
16379 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16380 {
16381 	unsigned int present;
16382 	unsigned char bits;
16383 
16384 	present = snd_hda_codec_read(codec, 0x14, 0,
16385 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16386 	bits = present ? HDA_AMP_MUTE : 0;
16387 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16388 				 HDA_AMP_MUTE, bits);
16389 }
16390 
16391 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16392 {
16393 	unsigned int present;
16394 	unsigned char bits;
16395 
16396  	present = snd_hda_codec_read(codec, 0x1b, 0,
16397 				     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16398 	bits = present ? HDA_AMP_MUTE : 0;
16399 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16400 				 HDA_AMP_MUTE, bits);
16401 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16402 				 HDA_AMP_MUTE, bits);
16403 }
16404 
16405 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16406 					   unsigned int res)
16407 {
16408 	if ((res >> 26) == ALC880_HP_EVENT)
16409 		alc662_lenovo_101e_all_automute(codec);
16410 	if ((res >> 26) == ALC880_FRONT_EVENT)
16411 		alc662_lenovo_101e_ispeaker_automute(codec);
16412 }
16413 
16414 /* unsolicited event for HP jack sensing */
16415 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16416 				     unsigned int res)
16417 {
16418 	if ((res >> 26) == ALC880_MIC_EVENT)
16419 		alc_mic_automute(codec);
16420 	else
16421 		alc262_hippo_unsol_event(codec, res);
16422 }
16423 
16424 static void alc662_eeepc_setup(struct hda_codec *codec)
16425 {
16426 	struct alc_spec *spec = codec->spec;
16427 
16428 	alc262_hippo1_setup(codec);
16429 	spec->ext_mic.pin = 0x18;
16430 	spec->ext_mic.mux_idx = 0;
16431 	spec->int_mic.pin = 0x19;
16432 	spec->int_mic.mux_idx = 1;
16433 	spec->auto_mic = 1;
16434 }
16435 
16436 static void alc662_eeepc_inithook(struct hda_codec *codec)
16437 {
16438 	alc262_hippo_automute(codec);
16439 	alc_mic_automute(codec);
16440 }
16441 
16442 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
16443 {
16444 	struct alc_spec *spec = codec->spec;
16445 
16446 	spec->autocfg.hp_pins[0] = 0x14;
16447 	spec->autocfg.speaker_pins[0] = 0x1b;
16448 }
16449 
16450 #define alc662_eeepc_ep20_inithook	alc262_hippo_master_update
16451 
16452 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16453 {
16454 	unsigned int present;
16455 	unsigned char bits;
16456 
16457 	present = snd_hda_codec_read(codec, 0x21, 0,
16458 			AC_VERB_GET_PIN_SENSE, 0)
16459 			& AC_PINSENSE_PRESENCE;
16460 	bits = present ? HDA_AMP_MUTE : 0;
16461 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16462 				AMP_IN_MUTE(0), bits);
16463 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16464 				AMP_IN_MUTE(0), bits);
16465 }
16466 
16467 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16468 {
16469 	unsigned int present;
16470 	unsigned char bits;
16471 
16472 	present = snd_hda_codec_read(codec, 0x21, 0,
16473 			AC_VERB_GET_PIN_SENSE, 0)
16474 			& AC_PINSENSE_PRESENCE;
16475 	bits = present ? HDA_AMP_MUTE : 0;
16476 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16477 				AMP_IN_MUTE(0), bits);
16478 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16479 				AMP_IN_MUTE(0), bits);
16480 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16481 				AMP_IN_MUTE(0), bits);
16482 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16483 				AMP_IN_MUTE(0), bits);
16484 }
16485 
16486 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16487 {
16488 	unsigned int present;
16489 	unsigned char bits;
16490 
16491 	present = snd_hda_codec_read(codec, 0x15, 0,
16492 			AC_VERB_GET_PIN_SENSE, 0)
16493 			& AC_PINSENSE_PRESENCE;
16494 	bits = present ? HDA_AMP_MUTE : 0;
16495 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16496 				AMP_IN_MUTE(0), bits);
16497 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16498 				AMP_IN_MUTE(0), bits);
16499 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16500 				AMP_IN_MUTE(0), bits);
16501 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16502 				AMP_IN_MUTE(0), bits);
16503 }
16504 
16505 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16506 {
16507 	unsigned int present;
16508 	unsigned char bits;
16509 
16510 	present = snd_hda_codec_read(codec, 0x1b, 0,
16511 			AC_VERB_GET_PIN_SENSE, 0)
16512 			& AC_PINSENSE_PRESENCE;
16513 	bits = present ? 0 : PIN_OUT;
16514 	snd_hda_codec_write(codec, 0x14, 0,
16515 			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16516 }
16517 
16518 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16519 {
16520 	unsigned int present1, present2;
16521 
16522 	present1 = snd_hda_codec_read(codec, 0x21, 0,
16523 			AC_VERB_GET_PIN_SENSE, 0)
16524 			& AC_PINSENSE_PRESENCE;
16525 	present2 = snd_hda_codec_read(codec, 0x15, 0,
16526 			AC_VERB_GET_PIN_SENSE, 0)
16527 			& AC_PINSENSE_PRESENCE;
16528 
16529 	if (present1 || present2) {
16530 		snd_hda_codec_write_cache(codec, 0x14, 0,
16531 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16532 	} else {
16533 		snd_hda_codec_write_cache(codec, 0x14, 0,
16534 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16535 	}
16536 }
16537 
16538 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16539 {
16540 	unsigned int present1, present2;
16541 
16542 	present1 = snd_hda_codec_read(codec, 0x1b, 0,
16543 				AC_VERB_GET_PIN_SENSE, 0)
16544 				& AC_PINSENSE_PRESENCE;
16545 	present2 = snd_hda_codec_read(codec, 0x15, 0,
16546 				AC_VERB_GET_PIN_SENSE, 0)
16547 				& AC_PINSENSE_PRESENCE;
16548 
16549 	if (present1 || present2) {
16550 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16551 				AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16552 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16553 				AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16554 	} else {
16555 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16556 				AMP_IN_MUTE(0), 0);
16557 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16558 				AMP_IN_MUTE(0), 0);
16559 	}
16560 }
16561 
16562 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16563 					   unsigned int res)
16564 {
16565 	switch (res >> 26) {
16566 	case ALC880_HP_EVENT:
16567 		alc663_m51va_speaker_automute(codec);
16568 		break;
16569 	case ALC880_MIC_EVENT:
16570 		alc_mic_automute(codec);
16571 		break;
16572 	}
16573 }
16574 
16575 static void alc663_m51va_setup(struct hda_codec *codec)
16576 {
16577 	struct alc_spec *spec = codec->spec;
16578 	spec->ext_mic.pin = 0x18;
16579 	spec->ext_mic.mux_idx = 0;
16580 	spec->int_mic.pin = 0x12;
16581 	spec->int_mic.mux_idx = 1;
16582 	spec->auto_mic = 1;
16583 }
16584 
16585 static void alc663_m51va_inithook(struct hda_codec *codec)
16586 {
16587 	alc663_m51va_speaker_automute(codec);
16588 	alc_mic_automute(codec);
16589 }
16590 
16591 /* ***************** Mode1 ******************************/
16592 #define alc663_mode1_unsol_event	alc663_m51va_unsol_event
16593 #define alc663_mode1_setup		alc663_m51va_setup
16594 #define alc663_mode1_inithook		alc663_m51va_inithook
16595 
16596 /* ***************** Mode2 ******************************/
16597 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16598 					   unsigned int res)
16599 {
16600 	switch (res >> 26) {
16601 	case ALC880_HP_EVENT:
16602 		alc662_f5z_speaker_automute(codec);
16603 		break;
16604 	case ALC880_MIC_EVENT:
16605 		alc_mic_automute(codec);
16606 		break;
16607 	}
16608 }
16609 
16610 #define alc662_mode2_setup	alc663_m51va_setup
16611 
16612 static void alc662_mode2_inithook(struct hda_codec *codec)
16613 {
16614 	alc662_f5z_speaker_automute(codec);
16615 	alc_mic_automute(codec);
16616 }
16617 /* ***************** Mode3 ******************************/
16618 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16619 					   unsigned int res)
16620 {
16621 	switch (res >> 26) {
16622 	case ALC880_HP_EVENT:
16623 		alc663_two_hp_m1_speaker_automute(codec);
16624 		break;
16625 	case ALC880_MIC_EVENT:
16626 		alc_mic_automute(codec);
16627 		break;
16628 	}
16629 }
16630 
16631 #define alc663_mode3_setup	alc663_m51va_setup
16632 
16633 static void alc663_mode3_inithook(struct hda_codec *codec)
16634 {
16635 	alc663_two_hp_m1_speaker_automute(codec);
16636 	alc_mic_automute(codec);
16637 }
16638 /* ***************** Mode4 ******************************/
16639 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16640 					   unsigned int res)
16641 {
16642 	switch (res >> 26) {
16643 	case ALC880_HP_EVENT:
16644 		alc663_21jd_two_speaker_automute(codec);
16645 		break;
16646 	case ALC880_MIC_EVENT:
16647 		alc_mic_automute(codec);
16648 		break;
16649 	}
16650 }
16651 
16652 #define alc663_mode4_setup	alc663_m51va_setup
16653 
16654 static void alc663_mode4_inithook(struct hda_codec *codec)
16655 {
16656 	alc663_21jd_two_speaker_automute(codec);
16657 	alc_mic_automute(codec);
16658 }
16659 /* ***************** Mode5 ******************************/
16660 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16661 					   unsigned int res)
16662 {
16663 	switch (res >> 26) {
16664 	case ALC880_HP_EVENT:
16665 		alc663_15jd_two_speaker_automute(codec);
16666 		break;
16667 	case ALC880_MIC_EVENT:
16668 		alc_mic_automute(codec);
16669 		break;
16670 	}
16671 }
16672 
16673 #define alc663_mode5_setup	alc663_m51va_setup
16674 
16675 static void alc663_mode5_inithook(struct hda_codec *codec)
16676 {
16677 	alc663_15jd_two_speaker_automute(codec);
16678 	alc_mic_automute(codec);
16679 }
16680 /* ***************** Mode6 ******************************/
16681 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16682 					   unsigned int res)
16683 {
16684 	switch (res >> 26) {
16685 	case ALC880_HP_EVENT:
16686 		alc663_two_hp_m2_speaker_automute(codec);
16687 		break;
16688 	case ALC880_MIC_EVENT:
16689 		alc_mic_automute(codec);
16690 		break;
16691 	}
16692 }
16693 
16694 #define alc663_mode6_setup	alc663_m51va_setup
16695 
16696 static void alc663_mode6_inithook(struct hda_codec *codec)
16697 {
16698 	alc663_two_hp_m2_speaker_automute(codec);
16699 	alc_mic_automute(codec);
16700 }
16701 
16702 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16703 {
16704 	unsigned int present;
16705 	unsigned char bits;
16706 
16707 	present = snd_hda_codec_read(codec, 0x21, 0,
16708 				     AC_VERB_GET_PIN_SENSE, 0)
16709 		& AC_PINSENSE_PRESENCE;
16710 	bits = present ? HDA_AMP_MUTE : 0;
16711 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16712 				 HDA_AMP_MUTE, bits);
16713 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16714 				 HDA_AMP_MUTE, bits);
16715 }
16716 
16717 static void alc663_g71v_front_automute(struct hda_codec *codec)
16718 {
16719 	unsigned int present;
16720 	unsigned char bits;
16721 
16722 	present = snd_hda_codec_read(codec, 0x15, 0,
16723 				     AC_VERB_GET_PIN_SENSE, 0)
16724 		& AC_PINSENSE_PRESENCE;
16725 	bits = present ? HDA_AMP_MUTE : 0;
16726 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16727 				 HDA_AMP_MUTE, bits);
16728 }
16729 
16730 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16731 					   unsigned int res)
16732 {
16733 	switch (res >> 26) {
16734 	case ALC880_HP_EVENT:
16735 		alc663_g71v_hp_automute(codec);
16736 		break;
16737 	case ALC880_FRONT_EVENT:
16738 		alc663_g71v_front_automute(codec);
16739 		break;
16740 	case ALC880_MIC_EVENT:
16741 		alc_mic_automute(codec);
16742 		break;
16743 	}
16744 }
16745 
16746 #define alc663_g71v_setup	alc663_m51va_setup
16747 
16748 static void alc663_g71v_inithook(struct hda_codec *codec)
16749 {
16750 	alc663_g71v_front_automute(codec);
16751 	alc663_g71v_hp_automute(codec);
16752 	alc_mic_automute(codec);
16753 }
16754 
16755 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16756 					   unsigned int res)
16757 {
16758 	switch (res >> 26) {
16759 	case ALC880_HP_EVENT:
16760 		alc663_m51va_speaker_automute(codec);
16761 		break;
16762 	case ALC880_MIC_EVENT:
16763 		alc_mic_automute(codec);
16764 		break;
16765 	}
16766 }
16767 
16768 #define alc663_g50v_setup	alc663_m51va_setup
16769 
16770 static void alc663_g50v_inithook(struct hda_codec *codec)
16771 {
16772 	alc663_m51va_speaker_automute(codec);
16773 	alc_mic_automute(codec);
16774 }
16775 
16776 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16777 	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16778 	ALC262_HIPPO_MASTER_SWITCH,
16779 
16780 	HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16781 	HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16782 	HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16783 
16784 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16785 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16786 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16787 	{ } /* end */
16788 };
16789 
16790 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16791 	/* Master Playback automatically created from Speaker and Headphone */
16792 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16793 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16794 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16795 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16796 
16797 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16798 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16799 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16800 
16801 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16802 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16803 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16804 	{ } /* end */
16805 };
16806 
16807 #ifdef CONFIG_SND_HDA_POWER_SAVE
16808 #define alc662_loopbacks	alc880_loopbacks
16809 #endif
16810 
16811 
16812 /* pcm configuration: identical with ALC880 */
16813 #define alc662_pcm_analog_playback	alc880_pcm_analog_playback
16814 #define alc662_pcm_analog_capture	alc880_pcm_analog_capture
16815 #define alc662_pcm_digital_playback	alc880_pcm_digital_playback
16816 #define alc662_pcm_digital_capture	alc880_pcm_digital_capture
16817 
16818 /*
16819  * configuration and preset
16820  */
16821 static const char *alc662_models[ALC662_MODEL_LAST] = {
16822 	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
16823 	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
16824 	[ALC662_3ST_6ch]	= "3stack-6ch",
16825 	[ALC662_5ST_DIG]	= "6stack-dig",
16826 	[ALC662_LENOVO_101E]	= "lenovo-101e",
16827 	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16828 	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16829 	[ALC662_ECS] = "ecs",
16830 	[ALC663_ASUS_M51VA] = "m51va",
16831 	[ALC663_ASUS_G71V] = "g71v",
16832 	[ALC663_ASUS_H13] = "h13",
16833 	[ALC663_ASUS_G50V] = "g50v",
16834 	[ALC663_ASUS_MODE1] = "asus-mode1",
16835 	[ALC662_ASUS_MODE2] = "asus-mode2",
16836 	[ALC663_ASUS_MODE3] = "asus-mode3",
16837 	[ALC663_ASUS_MODE4] = "asus-mode4",
16838 	[ALC663_ASUS_MODE5] = "asus-mode5",
16839 	[ALC663_ASUS_MODE6] = "asus-mode6",
16840 	[ALC272_DELL]		= "dell",
16841 	[ALC272_DELL_ZM1]	= "dell-zm1",
16842 	[ALC272_SAMSUNG_NC10]	= "samsung-nc10",
16843 	[ALC662_AUTO]		= "auto",
16844 };
16845 
16846 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16847 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16848 	SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16849 	SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16850 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16851 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16852 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16853 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16854 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16855 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16856 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16857 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16858 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16859 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16860 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16861 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16862 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16863 	SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16864 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16865 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16866 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16867 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16868 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16869 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16870 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16871 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16872 	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16873 	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16874 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16875 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16876 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16877 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16878 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16879 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16880 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16881 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16882 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16883 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16884 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16885 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16886 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16887 	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16888 	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16889 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16890 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16891 	SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16892 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16893 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16894 	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16895 	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16896 	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16897 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16898 	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16899 		      ALC662_3ST_6ch_DIG),
16900 	SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB200", ALC663_ASUS_MODE4),
16901 	SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16902 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16903 		      ALC662_3ST_6ch_DIG),
16904 	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16905 	SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16906 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16907 	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16908 					ALC662_3ST_6ch_DIG),
16909 	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16910 			   ALC663_ASUS_H13),
16911 	{}
16912 };
16913 
16914 static struct alc_config_preset alc662_presets[] = {
16915 	[ALC662_3ST_2ch_DIG] = {
16916 		.mixers = { alc662_3ST_2ch_mixer },
16917 		.init_verbs = { alc662_init_verbs },
16918 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16919 		.dac_nids = alc662_dac_nids,
16920 		.dig_out_nid = ALC662_DIGOUT_NID,
16921 		.dig_in_nid = ALC662_DIGIN_NID,
16922 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16923 		.channel_mode = alc662_3ST_2ch_modes,
16924 		.input_mux = &alc662_capture_source,
16925 	},
16926 	[ALC662_3ST_6ch_DIG] = {
16927 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16928 		.init_verbs = { alc662_init_verbs },
16929 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16930 		.dac_nids = alc662_dac_nids,
16931 		.dig_out_nid = ALC662_DIGOUT_NID,
16932 		.dig_in_nid = ALC662_DIGIN_NID,
16933 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16934 		.channel_mode = alc662_3ST_6ch_modes,
16935 		.need_dac_fix = 1,
16936 		.input_mux = &alc662_capture_source,
16937 	},
16938 	[ALC662_3ST_6ch] = {
16939 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16940 		.init_verbs = { alc662_init_verbs },
16941 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16942 		.dac_nids = alc662_dac_nids,
16943 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16944 		.channel_mode = alc662_3ST_6ch_modes,
16945 		.need_dac_fix = 1,
16946 		.input_mux = &alc662_capture_source,
16947 	},
16948 	[ALC662_5ST_DIG] = {
16949 		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
16950 		.init_verbs = { alc662_init_verbs },
16951 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16952 		.dac_nids = alc662_dac_nids,
16953 		.dig_out_nid = ALC662_DIGOUT_NID,
16954 		.dig_in_nid = ALC662_DIGIN_NID,
16955 		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16956 		.channel_mode = alc662_5stack_modes,
16957 		.input_mux = &alc662_capture_source,
16958 	},
16959 	[ALC662_LENOVO_101E] = {
16960 		.mixers = { alc662_lenovo_101e_mixer },
16961 		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16962 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16963 		.dac_nids = alc662_dac_nids,
16964 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16965 		.channel_mode = alc662_3ST_2ch_modes,
16966 		.input_mux = &alc662_lenovo_101e_capture_source,
16967 		.unsol_event = alc662_lenovo_101e_unsol_event,
16968 		.init_hook = alc662_lenovo_101e_all_automute,
16969 	},
16970 	[ALC662_ASUS_EEEPC_P701] = {
16971 		.mixers = { alc662_eeepc_p701_mixer },
16972 		.init_verbs = { alc662_init_verbs,
16973 				alc662_eeepc_sue_init_verbs },
16974 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16975 		.dac_nids = alc662_dac_nids,
16976 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16977 		.channel_mode = alc662_3ST_2ch_modes,
16978 		.unsol_event = alc662_eeepc_unsol_event,
16979 		.setup = alc662_eeepc_setup,
16980 		.init_hook = alc662_eeepc_inithook,
16981 	},
16982 	[ALC662_ASUS_EEEPC_EP20] = {
16983 		.mixers = { alc662_eeepc_ep20_mixer,
16984 			    alc662_chmode_mixer },
16985 		.init_verbs = { alc662_init_verbs,
16986 				alc662_eeepc_ep20_sue_init_verbs },
16987 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
16988 		.dac_nids = alc662_dac_nids,
16989 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16990 		.channel_mode = alc662_3ST_6ch_modes,
16991 		.input_mux = &alc662_lenovo_101e_capture_source,
16992 		.unsol_event = alc662_eeepc_unsol_event,
16993 		.setup = alc662_eeepc_ep20_setup,
16994 		.init_hook = alc662_eeepc_ep20_inithook,
16995 	},
16996 	[ALC662_ECS] = {
16997 		.mixers = { alc662_ecs_mixer },
16998 		.init_verbs = { alc662_init_verbs,
16999 				alc662_ecs_init_verbs },
17000 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17001 		.dac_nids = alc662_dac_nids,
17002 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17003 		.channel_mode = alc662_3ST_2ch_modes,
17004 		.unsol_event = alc662_eeepc_unsol_event,
17005 		.setup = alc662_eeepc_setup,
17006 		.init_hook = alc662_eeepc_inithook,
17007 	},
17008 	[ALC663_ASUS_M51VA] = {
17009 		.mixers = { alc663_m51va_mixer },
17010 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17011 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17012 		.dac_nids = alc662_dac_nids,
17013 		.dig_out_nid = ALC662_DIGOUT_NID,
17014 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17015 		.channel_mode = alc662_3ST_2ch_modes,
17016 		.unsol_event = alc663_m51va_unsol_event,
17017 		.setup = alc663_m51va_setup,
17018 		.init_hook = alc663_m51va_inithook,
17019 	},
17020 	[ALC663_ASUS_G71V] = {
17021 		.mixers = { alc663_g71v_mixer },
17022 		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17023 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17024 		.dac_nids = alc662_dac_nids,
17025 		.dig_out_nid = ALC662_DIGOUT_NID,
17026 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17027 		.channel_mode = alc662_3ST_2ch_modes,
17028 		.unsol_event = alc663_g71v_unsol_event,
17029 		.setup = alc663_g71v_setup,
17030 		.init_hook = alc663_g71v_inithook,
17031 	},
17032 	[ALC663_ASUS_H13] = {
17033 		.mixers = { alc663_m51va_mixer },
17034 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17035 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17036 		.dac_nids = alc662_dac_nids,
17037 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17038 		.channel_mode = alc662_3ST_2ch_modes,
17039 		.unsol_event = alc663_m51va_unsol_event,
17040 		.init_hook = alc663_m51va_inithook,
17041 	},
17042 	[ALC663_ASUS_G50V] = {
17043 		.mixers = { alc663_g50v_mixer },
17044 		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17045 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17046 		.dac_nids = alc662_dac_nids,
17047 		.dig_out_nid = ALC662_DIGOUT_NID,
17048 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17049 		.channel_mode = alc662_3ST_6ch_modes,
17050 		.input_mux = &alc663_capture_source,
17051 		.unsol_event = alc663_g50v_unsol_event,
17052 		.setup = alc663_g50v_setup,
17053 		.init_hook = alc663_g50v_inithook,
17054 	},
17055 	[ALC663_ASUS_MODE1] = {
17056 		.mixers = { alc663_m51va_mixer },
17057 		.cap_mixer = alc662_auto_capture_mixer,
17058 		.init_verbs = { alc662_init_verbs,
17059 				alc663_21jd_amic_init_verbs },
17060 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17061 		.hp_nid = 0x03,
17062 		.dac_nids = alc662_dac_nids,
17063 		.dig_out_nid = ALC662_DIGOUT_NID,
17064 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17065 		.channel_mode = alc662_3ST_2ch_modes,
17066 		.unsol_event = alc663_mode1_unsol_event,
17067 		.setup = alc663_mode1_setup,
17068 		.init_hook = alc663_mode1_inithook,
17069 	},
17070 	[ALC662_ASUS_MODE2] = {
17071 		.mixers = { alc662_1bjd_mixer },
17072 		.cap_mixer = alc662_auto_capture_mixer,
17073 		.init_verbs = { alc662_init_verbs,
17074 				alc662_1bjd_amic_init_verbs },
17075 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17076 		.dac_nids = alc662_dac_nids,
17077 		.dig_out_nid = ALC662_DIGOUT_NID,
17078 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17079 		.channel_mode = alc662_3ST_2ch_modes,
17080 		.unsol_event = alc662_mode2_unsol_event,
17081 		.setup = alc662_mode2_setup,
17082 		.init_hook = alc662_mode2_inithook,
17083 	},
17084 	[ALC663_ASUS_MODE3] = {
17085 		.mixers = { alc663_two_hp_m1_mixer },
17086 		.cap_mixer = alc662_auto_capture_mixer,
17087 		.init_verbs = { alc662_init_verbs,
17088 				alc663_two_hp_amic_m1_init_verbs },
17089 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17090 		.hp_nid = 0x03,
17091 		.dac_nids = alc662_dac_nids,
17092 		.dig_out_nid = ALC662_DIGOUT_NID,
17093 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17094 		.channel_mode = alc662_3ST_2ch_modes,
17095 		.unsol_event = alc663_mode3_unsol_event,
17096 		.setup = alc663_mode3_setup,
17097 		.init_hook = alc663_mode3_inithook,
17098 	},
17099 	[ALC663_ASUS_MODE4] = {
17100 		.mixers = { alc663_asus_21jd_clfe_mixer },
17101 		.cap_mixer = alc662_auto_capture_mixer,
17102 		.init_verbs = { alc662_init_verbs,
17103 				alc663_21jd_amic_init_verbs},
17104 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17105 		.hp_nid = 0x03,
17106 		.dac_nids = alc662_dac_nids,
17107 		.dig_out_nid = ALC662_DIGOUT_NID,
17108 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17109 		.channel_mode = alc662_3ST_2ch_modes,
17110 		.unsol_event = alc663_mode4_unsol_event,
17111 		.setup = alc663_mode4_setup,
17112 		.init_hook = alc663_mode4_inithook,
17113 	},
17114 	[ALC663_ASUS_MODE5] = {
17115 		.mixers = { alc663_asus_15jd_clfe_mixer },
17116 		.cap_mixer = alc662_auto_capture_mixer,
17117 		.init_verbs = { alc662_init_verbs,
17118 				alc663_15jd_amic_init_verbs },
17119 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17120 		.hp_nid = 0x03,
17121 		.dac_nids = alc662_dac_nids,
17122 		.dig_out_nid = ALC662_DIGOUT_NID,
17123 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17124 		.channel_mode = alc662_3ST_2ch_modes,
17125 		.unsol_event = alc663_mode5_unsol_event,
17126 		.setup = alc663_mode5_setup,
17127 		.init_hook = alc663_mode5_inithook,
17128 	},
17129 	[ALC663_ASUS_MODE6] = {
17130 		.mixers = { alc663_two_hp_m2_mixer },
17131 		.cap_mixer = alc662_auto_capture_mixer,
17132 		.init_verbs = { alc662_init_verbs,
17133 				alc663_two_hp_amic_m2_init_verbs },
17134 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17135 		.hp_nid = 0x03,
17136 		.dac_nids = alc662_dac_nids,
17137 		.dig_out_nid = ALC662_DIGOUT_NID,
17138 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17139 		.channel_mode = alc662_3ST_2ch_modes,
17140 		.unsol_event = alc663_mode6_unsol_event,
17141 		.setup = alc663_mode6_setup,
17142 		.init_hook = alc663_mode6_inithook,
17143 	},
17144 	[ALC272_DELL] = {
17145 		.mixers = { alc663_m51va_mixer },
17146 		.cap_mixer = alc272_auto_capture_mixer,
17147 		.init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17148 		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
17149 		.dac_nids = alc662_dac_nids,
17150 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17151 		.adc_nids = alc272_adc_nids,
17152 		.num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17153 		.capsrc_nids = alc272_capsrc_nids,
17154 		.channel_mode = alc662_3ST_2ch_modes,
17155 		.unsol_event = alc663_m51va_unsol_event,
17156 		.setup = alc663_m51va_setup,
17157 		.init_hook = alc663_m51va_inithook,
17158 	},
17159 	[ALC272_DELL_ZM1] = {
17160 		.mixers = { alc663_m51va_mixer },
17161 		.cap_mixer = alc662_auto_capture_mixer,
17162 		.init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17163 		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
17164 		.dac_nids = alc662_dac_nids,
17165 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17166 		.adc_nids = alc662_adc_nids,
17167 		.num_adc_nids = 1,
17168 		.capsrc_nids = alc662_capsrc_nids,
17169 		.channel_mode = alc662_3ST_2ch_modes,
17170 		.unsol_event = alc663_m51va_unsol_event,
17171 		.setup = alc663_m51va_setup,
17172 		.init_hook = alc663_m51va_inithook,
17173 	},
17174 	[ALC272_SAMSUNG_NC10] = {
17175 		.mixers = { alc272_nc10_mixer },
17176 		.init_verbs = { alc662_init_verbs,
17177 				alc663_21jd_amic_init_verbs },
17178 		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
17179 		.dac_nids = alc272_dac_nids,
17180 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17181 		.channel_mode = alc662_3ST_2ch_modes,
17182 		/*.input_mux = &alc272_nc10_capture_source,*/
17183 		.unsol_event = alc663_mode4_unsol_event,
17184 		.setup = alc663_mode4_setup,
17185 		.init_hook = alc663_mode4_inithook,
17186 	},
17187 };
17188 
17189 
17190 /*
17191  * BIOS auto configuration
17192  */
17193 
17194 /* convert from MIX nid to DAC */
17195 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
17196 {
17197 	if (nid == 0x0f)
17198 		return 0x02;
17199 	else if (nid >= 0x0c && nid <= 0x0e)
17200 		return nid - 0x0c + 0x02;
17201 	else
17202 		return 0;
17203 }
17204 
17205 /* get MIX nid connected to the given pin targeted to DAC */
17206 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
17207 				   hda_nid_t dac)
17208 {
17209 	hda_nid_t mix[4];
17210 	int i, num;
17211 
17212 	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
17213 	for (i = 0; i < num; i++) {
17214 		if (alc662_mix_to_dac(mix[i]) == dac)
17215 			return mix[i];
17216 	}
17217 	return 0;
17218 }
17219 
17220 /* look for an empty DAC slot */
17221 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
17222 {
17223 	struct alc_spec *spec = codec->spec;
17224 	hda_nid_t srcs[5];
17225 	int i, j, num;
17226 
17227 	num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
17228 	if (num < 0)
17229 		return 0;
17230 	for (i = 0; i < num; i++) {
17231 		hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
17232 		if (!nid)
17233 			continue;
17234 		for (j = 0; j < spec->multiout.num_dacs; j++)
17235 			if (spec->multiout.dac_nids[j] == nid)
17236 				break;
17237 		if (j >= spec->multiout.num_dacs)
17238 			return nid;
17239 	}
17240 	return 0;
17241 }
17242 
17243 /* fill in the dac_nids table from the parsed pin configuration */
17244 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
17245 				     const struct auto_pin_cfg *cfg)
17246 {
17247 	struct alc_spec *spec = codec->spec;
17248 	int i;
17249 	hda_nid_t dac;
17250 
17251 	spec->multiout.dac_nids = spec->private_dac_nids;
17252 	for (i = 0; i < cfg->line_outs; i++) {
17253 		dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
17254 		if (!dac)
17255 			continue;
17256 		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
17257 	}
17258 	return 0;
17259 }
17260 
17261 static int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
17262 			      hda_nid_t nid, unsigned int chs)
17263 {
17264 	char name[32];
17265 	sprintf(name, "%s Playback Volume", pfx);
17266 	return add_control(spec, ALC_CTL_WIDGET_VOL, name,
17267 			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
17268 }
17269 
17270 static int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
17271 			     hda_nid_t nid, unsigned int chs)
17272 {
17273 	char name[32];
17274 	sprintf(name, "%s Playback Switch", pfx);
17275 	return add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17276 			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
17277 }
17278 
17279 #define alc662_add_stereo_vol(spec, pfx, nid) \
17280 	alc662_add_vol_ctl(spec, pfx, nid, 3)
17281 #define alc662_add_stereo_sw(spec, pfx, nid) \
17282 	alc662_add_sw_ctl(spec, pfx, nid, 3)
17283 
17284 /* add playback controls from the parsed DAC table */
17285 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
17286 					     const struct auto_pin_cfg *cfg)
17287 {
17288 	struct alc_spec *spec = codec->spec;
17289 	static const char *chname[4] = {
17290 		"Front", "Surround", NULL /*CLFE*/, "Side"
17291 	};
17292 	hda_nid_t nid, mix;
17293 	int i, err;
17294 
17295 	for (i = 0; i < cfg->line_outs; i++) {
17296 		nid = spec->multiout.dac_nids[i];
17297 		if (!nid)
17298 			continue;
17299 		mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
17300 		if (!mix)
17301 			continue;
17302 		if (i == 2) {
17303 			/* Center/LFE */
17304 			err = alc662_add_vol_ctl(spec, "Center", nid, 1);
17305 			if (err < 0)
17306 				return err;
17307 			err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
17308 			if (err < 0)
17309 				return err;
17310 			err = alc662_add_sw_ctl(spec, "Center", mix, 1);
17311 			if (err < 0)
17312 				return err;
17313 			err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
17314 			if (err < 0)
17315 				return err;
17316 		} else {
17317 			const char *pfx;
17318 			if (cfg->line_outs == 1 &&
17319 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17320 				if (cfg->hp_outs)
17321 					pfx = "Speaker";
17322 				else
17323 					pfx = "PCM";
17324 			} else
17325 				pfx = chname[i];
17326 			err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17327 			if (err < 0)
17328 				return err;
17329 			if (cfg->line_outs == 1 &&
17330 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17331 				pfx = "Speaker";
17332 			err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17333 			if (err < 0)
17334 				return err;
17335 		}
17336 	}
17337 	return 0;
17338 }
17339 
17340 /* add playback controls for speaker and HP outputs */
17341 /* return DAC nid if any new DAC is assigned */
17342 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
17343 					const char *pfx)
17344 {
17345 	struct alc_spec *spec = codec->spec;
17346 	hda_nid_t nid, mix;
17347 	int err;
17348 
17349 	if (!pin)
17350 		return 0;
17351 	nid = alc662_look_for_dac(codec, pin);
17352 	if (!nid) {
17353 		char name[32];
17354 		/* the corresponding DAC is already occupied */
17355 		if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
17356 			return 0; /* no way */
17357 		/* create a switch only */
17358 		sprintf(name, "%s Playback Switch", pfx);
17359 		return add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17360 				   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17361 	}
17362 
17363 	mix = alc662_dac_to_mix(codec, pin, nid);
17364 	if (!mix)
17365 		return 0;
17366 	err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17367 	if (err < 0)
17368 		return err;
17369 	err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17370 	if (err < 0)
17371 		return err;
17372 	return nid;
17373 }
17374 
17375 /* create playback/capture controls for input pins */
17376 #define alc662_auto_create_input_ctls \
17377 	alc880_auto_create_input_ctls
17378 
17379 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17380 					      hda_nid_t nid, int pin_type,
17381 					      hda_nid_t dac)
17382 {
17383 	int i, num;
17384 	hda_nid_t srcs[4];
17385 
17386 	alc_set_pin_output(codec, nid, pin_type);
17387 	/* need the manual connection? */
17388 	num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
17389 	if (num <= 1)
17390 		return;
17391 	for (i = 0; i < num; i++) {
17392 		if (alc662_mix_to_dac(srcs[i]) != dac)
17393 			continue;
17394 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
17395 		return;
17396 	}
17397 }
17398 
17399 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17400 {
17401 	struct alc_spec *spec = codec->spec;
17402 	int pin_type = get_pin_type(spec->autocfg.line_out_type);
17403 	int i;
17404 
17405 	for (i = 0; i <= HDA_SIDE; i++) {
17406 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
17407 		if (nid)
17408 			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17409 					spec->multiout.dac_nids[i]);
17410 	}
17411 }
17412 
17413 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17414 {
17415 	struct alc_spec *spec = codec->spec;
17416 	hda_nid_t pin;
17417 
17418 	pin = spec->autocfg.hp_pins[0];
17419 	if (pin)
17420 		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
17421 						  spec->multiout.hp_nid);
17422 	pin = spec->autocfg.speaker_pins[0];
17423 	if (pin)
17424 		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
17425 					spec->multiout.extra_out_nid[0]);
17426 }
17427 
17428 #define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
17429 
17430 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17431 {
17432 	struct alc_spec *spec = codec->spec;
17433 	int i;
17434 
17435 	for (i = 0; i < AUTO_PIN_LAST; i++) {
17436 		hda_nid_t nid = spec->autocfg.input_pins[i];
17437 		if (alc_is_input_pin(codec, nid)) {
17438 			alc_set_input_pin(codec, nid, i);
17439 			if (nid != ALC662_PIN_CD_NID &&
17440 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17441 				snd_hda_codec_write(codec, nid, 0,
17442 						    AC_VERB_SET_AMP_GAIN_MUTE,
17443 						    AMP_OUT_MUTE);
17444 		}
17445 	}
17446 }
17447 
17448 #define alc662_auto_init_input_src	alc882_auto_init_input_src
17449 
17450 static int alc662_parse_auto_config(struct hda_codec *codec)
17451 {
17452 	struct alc_spec *spec = codec->spec;
17453 	int err;
17454 	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17455 
17456 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17457 					   alc662_ignore);
17458 	if (err < 0)
17459 		return err;
17460 	if (!spec->autocfg.line_outs)
17461 		return 0; /* can't find valid BIOS pin config */
17462 
17463 	err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
17464 	if (err < 0)
17465 		return err;
17466 	err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
17467 	if (err < 0)
17468 		return err;
17469 	err = alc662_auto_create_extra_out(codec,
17470 					   spec->autocfg.speaker_pins[0],
17471 					   "Speaker");
17472 	if (err < 0)
17473 		return err;
17474 	if (err)
17475 		spec->multiout.extra_out_nid[0] = err;
17476 	err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
17477 					   "Headphone");
17478 	if (err < 0)
17479 		return err;
17480 	if (err)
17481 		spec->multiout.hp_nid = err;
17482 	err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
17483 	if (err < 0)
17484 		return err;
17485 
17486 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17487 
17488 	if (spec->autocfg.dig_outs)
17489 		spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17490 
17491 	if (spec->kctls.list)
17492 		add_mixer(spec, spec->kctls.list);
17493 
17494 	spec->num_mux_defs = 1;
17495 	spec->input_mux = &spec->private_imux[0];
17496 
17497 	add_verb(spec, alc662_auto_init_verbs);
17498 	if (codec->vendor_id == 0x10ec0663)
17499 		add_verb(spec, alc663_auto_init_verbs);
17500 
17501 	err = alc_auto_add_mic_boost(codec);
17502 	if (err < 0)
17503 		return err;
17504 
17505 	alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17506 
17507 	return 1;
17508 }
17509 
17510 /* additional initialization for auto-configuration model */
17511 static void alc662_auto_init(struct hda_codec *codec)
17512 {
17513 	struct alc_spec *spec = codec->spec;
17514 	alc662_auto_init_multi_out(codec);
17515 	alc662_auto_init_hp_out(codec);
17516 	alc662_auto_init_analog_input(codec);
17517 	alc662_auto_init_input_src(codec);
17518 	if (spec->unsol_event)
17519 		alc_inithook(codec);
17520 }
17521 
17522 static int patch_alc662(struct hda_codec *codec)
17523 {
17524 	struct alc_spec *spec;
17525 	int err, board_config;
17526 
17527 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17528 	if (!spec)
17529 		return -ENOMEM;
17530 
17531 	codec->spec = spec;
17532 
17533 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
17534 
17535 	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17536 						  alc662_models,
17537 			  	                  alc662_cfg_tbl);
17538 	if (board_config < 0) {
17539 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17540 		       codec->chip_name);
17541 		board_config = ALC662_AUTO;
17542 	}
17543 
17544 	if (board_config == ALC662_AUTO) {
17545 		/* automatic parse from the BIOS config */
17546 		err = alc662_parse_auto_config(codec);
17547 		if (err < 0) {
17548 			alc_free(codec);
17549 			return err;
17550 		} else if (!err) {
17551 			printk(KERN_INFO
17552 			       "hda_codec: Cannot set up configuration "
17553 			       "from BIOS.  Using base mode...\n");
17554 			board_config = ALC662_3ST_2ch_DIG;
17555 		}
17556 	}
17557 
17558 	err = snd_hda_attach_beep_device(codec, 0x1);
17559 	if (err < 0) {
17560 		alc_free(codec);
17561 		return err;
17562 	}
17563 
17564 	if (board_config != ALC662_AUTO)
17565 		setup_preset(codec, &alc662_presets[board_config]);
17566 
17567 	spec->stream_analog_playback = &alc662_pcm_analog_playback;
17568 	spec->stream_analog_capture = &alc662_pcm_analog_capture;
17569 
17570 	spec->stream_digital_playback = &alc662_pcm_digital_playback;
17571 	spec->stream_digital_capture = &alc662_pcm_digital_capture;
17572 
17573 	if (!spec->adc_nids) {
17574 		spec->adc_nids = alc662_adc_nids;
17575 		spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17576 	}
17577 	if (!spec->capsrc_nids)
17578 		spec->capsrc_nids = alc662_capsrc_nids;
17579 
17580 	if (!spec->cap_mixer)
17581 		set_capture_mixer(codec);
17582 	if (codec->vendor_id == 0x10ec0662)
17583 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17584 	else
17585 		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17586 
17587 	spec->vmaster_nid = 0x02;
17588 
17589 	codec->patch_ops = alc_patch_ops;
17590 	if (board_config == ALC662_AUTO)
17591 		spec->init_hook = alc662_auto_init;
17592 #ifdef CONFIG_SND_HDA_POWER_SAVE
17593 	if (!spec->loopback.amplist)
17594 		spec->loopback.amplist = alc662_loopbacks;
17595 #endif
17596 	codec->proc_widget_hook = print_realtek_coef;
17597 
17598 	return 0;
17599 }
17600 
17601 /*
17602  * patch entries
17603  */
17604 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17605 	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17606 	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17607 	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17608 	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17609 	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17610 	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17611 	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17612 	  .patch = patch_alc861 },
17613 	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17614 	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17615 	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17616 	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17617 	  .patch = patch_alc882 },
17618 	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17619 	  .patch = patch_alc662 },
17620 	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17621 	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17622 	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17623 	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
17624 	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17625 	  .patch = patch_alc882 },
17626 	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17627 	  .patch = patch_alc882 },
17628 	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17629 	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
17630 	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17631 	  .patch = patch_alc882 },
17632 	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
17633 	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
17634 	{} /* terminator */
17635 };
17636 
17637 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17638 
17639 MODULE_LICENSE("GPL");
17640 MODULE_DESCRIPTION("Realtek HD-audio codec");
17641 
17642 static struct hda_codec_preset_list realtek_list = {
17643 	.preset = snd_hda_preset_realtek,
17644 	.owner = THIS_MODULE,
17645 };
17646 
17647 static int __init patch_realtek_init(void)
17648 {
17649 	return snd_hda_add_codec_preset(&realtek_list);
17650 }
17651 
17652 static void __exit patch_realtek_exit(void)
17653 {
17654 	snd_hda_delete_codec_preset(&realtek_list);
17655 }
17656 
17657 module_init(patch_realtek_init)
17658 module_exit(patch_realtek_exit)
17659