xref: /openbmc/linux/sound/pci/hda/patch_realtek.c (revision 4dc7ccf7) 
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_AMIC,
135 	ALC269_DMIC,
136 	ALC269VB_AMIC,
137 	ALC269VB_DMIC,
138 	ALC269_FUJITSU,
139 	ALC269_LIFEBOOK,
140 	ALC269_AUTO,
141 	ALC269_MODEL_LAST /* last tag */
142 };
143 
144 /* ALC861 models */
145 enum {
146 	ALC861_3ST,
147 	ALC660_3ST,
148 	ALC861_3ST_DIG,
149 	ALC861_6ST_DIG,
150 	ALC861_UNIWILL_M31,
151 	ALC861_TOSHIBA,
152 	ALC861_ASUS,
153 	ALC861_ASUS_LAPTOP,
154 	ALC861_AUTO,
155 	ALC861_MODEL_LAST,
156 };
157 
158 /* ALC861-VD models */
159 enum {
160 	ALC660VD_3ST,
161 	ALC660VD_3ST_DIG,
162 	ALC660VD_ASUS_V1S,
163 	ALC861VD_3ST,
164 	ALC861VD_3ST_DIG,
165 	ALC861VD_6ST_DIG,
166 	ALC861VD_LENOVO,
167 	ALC861VD_DALLAS,
168 	ALC861VD_HP,
169 	ALC861VD_AUTO,
170 	ALC861VD_MODEL_LAST,
171 };
172 
173 /* ALC662 models */
174 enum {
175 	ALC662_3ST_2ch_DIG,
176 	ALC662_3ST_6ch_DIG,
177 	ALC662_3ST_6ch,
178 	ALC662_5ST_DIG,
179 	ALC662_LENOVO_101E,
180 	ALC662_ASUS_EEEPC_P701,
181 	ALC662_ASUS_EEEPC_EP20,
182 	ALC663_ASUS_M51VA,
183 	ALC663_ASUS_G71V,
184 	ALC663_ASUS_H13,
185 	ALC663_ASUS_G50V,
186 	ALC662_ECS,
187 	ALC663_ASUS_MODE1,
188 	ALC662_ASUS_MODE2,
189 	ALC663_ASUS_MODE3,
190 	ALC663_ASUS_MODE4,
191 	ALC663_ASUS_MODE5,
192 	ALC663_ASUS_MODE6,
193 	ALC663_ASUS_MODE7,
194 	ALC663_ASUS_MODE8,
195 	ALC272_DELL,
196 	ALC272_DELL_ZM1,
197 	ALC272_SAMSUNG_NC10,
198 	ALC662_AUTO,
199 	ALC662_MODEL_LAST,
200 };
201 
202 /* ALC882 models */
203 enum {
204 	ALC882_3ST_DIG,
205 	ALC882_6ST_DIG,
206 	ALC882_ARIMA,
207 	ALC882_W2JC,
208 	ALC882_TARGA,
209 	ALC882_ASUS_A7J,
210 	ALC882_ASUS_A7M,
211 	ALC885_MACPRO,
212 	ALC885_MBA21,
213 	ALC885_MBP3,
214 	ALC885_MB5,
215 	ALC885_MACMINI3,
216 	ALC885_IMAC24,
217 	ALC885_IMAC91,
218 	ALC883_3ST_2ch_DIG,
219 	ALC883_3ST_6ch_DIG,
220 	ALC883_3ST_6ch,
221 	ALC883_6ST_DIG,
222 	ALC883_TARGA_DIG,
223 	ALC883_TARGA_2ch_DIG,
224 	ALC883_TARGA_8ch_DIG,
225 	ALC883_ACER,
226 	ALC883_ACER_ASPIRE,
227 	ALC888_ACER_ASPIRE_4930G,
228 	ALC888_ACER_ASPIRE_6530G,
229 	ALC888_ACER_ASPIRE_8930G,
230 	ALC888_ACER_ASPIRE_7730G,
231 	ALC883_MEDION,
232 	ALC883_MEDION_MD2,
233 	ALC883_LAPTOP_EAPD,
234 	ALC883_LENOVO_101E_2ch,
235 	ALC883_LENOVO_NB0763,
236 	ALC888_LENOVO_MS7195_DIG,
237 	ALC888_LENOVO_SKY,
238 	ALC883_HAIER_W66,
239 	ALC888_3ST_HP,
240 	ALC888_6ST_DELL,
241 	ALC883_MITAC,
242 	ALC883_CLEVO_M540R,
243 	ALC883_CLEVO_M720,
244 	ALC883_FUJITSU_PI2515,
245 	ALC888_FUJITSU_XA3530,
246 	ALC883_3ST_6ch_INTEL,
247 	ALC889A_INTEL,
248 	ALC889_INTEL,
249 	ALC888_ASUS_M90V,
250 	ALC888_ASUS_EEE1601,
251 	ALC889A_MB31,
252 	ALC1200_ASUS_P5Q,
253 	ALC883_SONY_VAIO_TT,
254 	ALC882_AUTO,
255 	ALC882_MODEL_LAST,
256 };
257 
258 /* for GPIO Poll */
259 #define GPIO_MASK	0x03
260 
261 /* extra amp-initialization sequence types */
262 enum {
263 	ALC_INIT_NONE,
264 	ALC_INIT_DEFAULT,
265 	ALC_INIT_GPIO1,
266 	ALC_INIT_GPIO2,
267 	ALC_INIT_GPIO3,
268 };
269 
270 struct alc_mic_route {
271 	hda_nid_t pin;
272 	unsigned char mux_idx;
273 	unsigned char amix_idx;
274 };
275 
276 #define MUX_IDX_UNDEF	((unsigned char)-1)
277 
278 struct alc_spec {
279 	/* codec parameterization */
280 	struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
281 	unsigned int num_mixers;
282 	struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
283 	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
284 
285 	const struct hda_verb *init_verbs[10];	/* initialization verbs
286 						 * don't forget NULL
287 						 * termination!
288 						 */
289 	unsigned int num_init_verbs;
290 
291 	char stream_name_analog[32];	/* analog PCM stream */
292 	struct hda_pcm_stream *stream_analog_playback;
293 	struct hda_pcm_stream *stream_analog_capture;
294 	struct hda_pcm_stream *stream_analog_alt_playback;
295 	struct hda_pcm_stream *stream_analog_alt_capture;
296 
297 	char stream_name_digital[32];	/* digital PCM stream */
298 	struct hda_pcm_stream *stream_digital_playback;
299 	struct hda_pcm_stream *stream_digital_capture;
300 
301 	/* playback */
302 	struct hda_multi_out multiout;	/* playback set-up
303 					 * max_channels, dacs must be set
304 					 * dig_out_nid and hp_nid are optional
305 					 */
306 	hda_nid_t alt_dac_nid;
307 	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
308 	int dig_out_type;
309 
310 	/* capture */
311 	unsigned int num_adc_nids;
312 	hda_nid_t *adc_nids;
313 	hda_nid_t *capsrc_nids;
314 	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
315 
316 	/* capture source */
317 	unsigned int num_mux_defs;
318 	const struct hda_input_mux *input_mux;
319 	unsigned int cur_mux[3];
320 	struct alc_mic_route ext_mic;
321 	struct alc_mic_route int_mic;
322 
323 	/* channel model */
324 	const struct hda_channel_mode *channel_mode;
325 	int num_channel_mode;
326 	int need_dac_fix;
327 	int const_channel_count;
328 	int ext_channel_count;
329 
330 	/* PCM information */
331 	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
332 
333 	/* dynamic controls, init_verbs and input_mux */
334 	struct auto_pin_cfg autocfg;
335 	struct snd_array kctls;
336 	struct hda_input_mux private_imux[3];
337 	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
338 	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
339 	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
340 
341 	/* hooks */
342 	void (*init_hook)(struct hda_codec *codec);
343 	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
344 #ifdef CONFIG_SND_HDA_POWER_SAVE
345 	void (*power_hook)(struct hda_codec *codec);
346 #endif
347 
348 	/* for pin sensing */
349 	unsigned int sense_updated: 1;
350 	unsigned int jack_present: 1;
351 	unsigned int master_sw: 1;
352 	unsigned int auto_mic:1;
353 
354 	/* other flags */
355 	unsigned int no_analog :1; /* digital I/O only */
356 	int init_amp;
357 
358 	/* for virtual master */
359 	hda_nid_t vmaster_nid;
360 #ifdef CONFIG_SND_HDA_POWER_SAVE
361 	struct hda_loopback_check loopback;
362 #endif
363 
364 	/* for PLL fix */
365 	hda_nid_t pll_nid;
366 	unsigned int pll_coef_idx, pll_coef_bit;
367 };
368 
369 /*
370  * configuration template - to be copied to the spec instance
371  */
372 struct alc_config_preset {
373 	struct snd_kcontrol_new *mixers[5]; /* should be identical size
374 					     * with spec
375 					     */
376 	struct snd_kcontrol_new *cap_mixer; /* capture mixer */
377 	const struct hda_verb *init_verbs[5];
378 	unsigned int num_dacs;
379 	hda_nid_t *dac_nids;
380 	hda_nid_t dig_out_nid;		/* optional */
381 	hda_nid_t hp_nid;		/* optional */
382 	hda_nid_t *slave_dig_outs;
383 	unsigned int num_adc_nids;
384 	hda_nid_t *adc_nids;
385 	hda_nid_t *capsrc_nids;
386 	hda_nid_t dig_in_nid;
387 	unsigned int num_channel_mode;
388 	const struct hda_channel_mode *channel_mode;
389 	int need_dac_fix;
390 	int const_channel_count;
391 	unsigned int num_mux_defs;
392 	const struct hda_input_mux *input_mux;
393 	void (*unsol_event)(struct hda_codec *, unsigned int);
394 	void (*setup)(struct hda_codec *);
395 	void (*init_hook)(struct hda_codec *);
396 #ifdef CONFIG_SND_HDA_POWER_SAVE
397 	struct hda_amp_list *loopbacks;
398 	void (*power_hook)(struct hda_codec *codec);
399 #endif
400 };
401 
402 
403 /*
404  * input MUX handling
405  */
406 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
407 			     struct snd_ctl_elem_info *uinfo)
408 {
409 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
410 	struct alc_spec *spec = codec->spec;
411 	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
412 	if (mux_idx >= spec->num_mux_defs)
413 		mux_idx = 0;
414 	if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
415 		mux_idx = 0;
416 	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
417 }
418 
419 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
420 			    struct snd_ctl_elem_value *ucontrol)
421 {
422 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
423 	struct alc_spec *spec = codec->spec;
424 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
425 
426 	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
427 	return 0;
428 }
429 
430 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
431 			    struct snd_ctl_elem_value *ucontrol)
432 {
433 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
434 	struct alc_spec *spec = codec->spec;
435 	const struct hda_input_mux *imux;
436 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
437 	unsigned int mux_idx;
438 	hda_nid_t nid = spec->capsrc_nids ?
439 		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
440 	unsigned int type;
441 
442 	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
443 	imux = &spec->input_mux[mux_idx];
444 	if (!imux->num_items && mux_idx > 0)
445 		imux = &spec->input_mux[0];
446 
447 	type = get_wcaps_type(get_wcaps(codec, nid));
448 	if (type == AC_WID_AUD_MIX) {
449 		/* Matrix-mixer style (e.g. ALC882) */
450 		unsigned int *cur_val = &spec->cur_mux[adc_idx];
451 		unsigned int i, idx;
452 
453 		idx = ucontrol->value.enumerated.item[0];
454 		if (idx >= imux->num_items)
455 			idx = imux->num_items - 1;
456 		if (*cur_val == idx)
457 			return 0;
458 		for (i = 0; i < imux->num_items; i++) {
459 			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
460 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
461 						 imux->items[i].index,
462 						 HDA_AMP_MUTE, v);
463 		}
464 		*cur_val = idx;
465 		return 1;
466 	} else {
467 		/* MUX style (e.g. ALC880) */
468 		return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
469 					     &spec->cur_mux[adc_idx]);
470 	}
471 }
472 
473 /*
474  * channel mode setting
475  */
476 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
477 			    struct snd_ctl_elem_info *uinfo)
478 {
479 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
480 	struct alc_spec *spec = codec->spec;
481 	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
482 				    spec->num_channel_mode);
483 }
484 
485 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
486 			   struct snd_ctl_elem_value *ucontrol)
487 {
488 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
489 	struct alc_spec *spec = codec->spec;
490 	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
491 				   spec->num_channel_mode,
492 				   spec->ext_channel_count);
493 }
494 
495 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
496 			   struct snd_ctl_elem_value *ucontrol)
497 {
498 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
499 	struct alc_spec *spec = codec->spec;
500 	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
501 				      spec->num_channel_mode,
502 				      &spec->ext_channel_count);
503 	if (err >= 0 && !spec->const_channel_count) {
504 		spec->multiout.max_channels = spec->ext_channel_count;
505 		if (spec->need_dac_fix)
506 			spec->multiout.num_dacs = spec->multiout.max_channels / 2;
507 	}
508 	return err;
509 }
510 
511 /*
512  * Control the mode of pin widget settings via the mixer.  "pc" is used
513  * instead of "%" to avoid consequences of accidently treating the % as
514  * being part of a format specifier.  Maximum allowed length of a value is
515  * 63 characters plus NULL terminator.
516  *
517  * Note: some retasking pin complexes seem to ignore requests for input
518  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
519  * are requested.  Therefore order this list so that this behaviour will not
520  * cause problems when mixer clients move through the enum sequentially.
521  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
522  * March 2006.
523  */
524 static char *alc_pin_mode_names[] = {
525 	"Mic 50pc bias", "Mic 80pc bias",
526 	"Line in", "Line out", "Headphone out",
527 };
528 static unsigned char alc_pin_mode_values[] = {
529 	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
530 };
531 /* The control can present all 5 options, or it can limit the options based
532  * in the pin being assumed to be exclusively an input or an output pin.  In
533  * addition, "input" pins may or may not process the mic bias option
534  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
535  * accept requests for bias as of chip versions up to March 2006) and/or
536  * wiring in the computer.
537  */
538 #define ALC_PIN_DIR_IN              0x00
539 #define ALC_PIN_DIR_OUT             0x01
540 #define ALC_PIN_DIR_INOUT           0x02
541 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
542 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
543 
544 /* Info about the pin modes supported by the different pin direction modes.
545  * For each direction the minimum and maximum values are given.
546  */
547 static signed char alc_pin_mode_dir_info[5][2] = {
548 	{ 0, 2 },    /* ALC_PIN_DIR_IN */
549 	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
550 	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
551 	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
552 	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
553 };
554 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
555 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
556 #define alc_pin_mode_n_items(_dir) \
557 	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
558 
559 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
560 			     struct snd_ctl_elem_info *uinfo)
561 {
562 	unsigned int item_num = uinfo->value.enumerated.item;
563 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
564 
565 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
566 	uinfo->count = 1;
567 	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
568 
569 	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
570 		item_num = alc_pin_mode_min(dir);
571 	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
572 	return 0;
573 }
574 
575 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
576 			    struct snd_ctl_elem_value *ucontrol)
577 {
578 	unsigned int i;
579 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
580 	hda_nid_t nid = kcontrol->private_value & 0xffff;
581 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
582 	long *valp = ucontrol->value.integer.value;
583 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
584 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
585 						 0x00);
586 
587 	/* Find enumerated value for current pinctl setting */
588 	i = alc_pin_mode_min(dir);
589 	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
590 		i++;
591 	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
592 	return 0;
593 }
594 
595 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
596 			    struct snd_ctl_elem_value *ucontrol)
597 {
598 	signed int change;
599 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
600 	hda_nid_t nid = kcontrol->private_value & 0xffff;
601 	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
602 	long val = *ucontrol->value.integer.value;
603 	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
604 						 AC_VERB_GET_PIN_WIDGET_CONTROL,
605 						 0x00);
606 
607 	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
608 		val = alc_pin_mode_min(dir);
609 
610 	change = pinctl != alc_pin_mode_values[val];
611 	if (change) {
612 		/* Set pin mode to that requested */
613 		snd_hda_codec_write_cache(codec, nid, 0,
614 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
615 					  alc_pin_mode_values[val]);
616 
617 		/* Also enable the retasking pin's input/output as required
618 		 * for the requested pin mode.  Enum values of 2 or less are
619 		 * input modes.
620 		 *
621 		 * Dynamically switching the input/output buffers probably
622 		 * reduces noise slightly (particularly on input) so we'll
623 		 * do it.  However, having both input and output buffers
624 		 * enabled simultaneously doesn't seem to be problematic if
625 		 * this turns out to be necessary in the future.
626 		 */
627 		if (val <= 2) {
628 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
629 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
630 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
631 						 HDA_AMP_MUTE, 0);
632 		} else {
633 			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
634 						 HDA_AMP_MUTE, HDA_AMP_MUTE);
635 			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
636 						 HDA_AMP_MUTE, 0);
637 		}
638 	}
639 	return change;
640 }
641 
642 #define ALC_PIN_MODE(xname, nid, dir) \
643 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
644 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
645 	  .info = alc_pin_mode_info, \
646 	  .get = alc_pin_mode_get, \
647 	  .put = alc_pin_mode_put, \
648 	  .private_value = nid | (dir<<16) }
649 
650 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
651  * together using a mask with more than one bit set.  This control is
652  * currently used only by the ALC260 test model.  At this stage they are not
653  * needed for any "production" models.
654  */
655 #ifdef CONFIG_SND_DEBUG
656 #define alc_gpio_data_info	snd_ctl_boolean_mono_info
657 
658 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
659 			     struct snd_ctl_elem_value *ucontrol)
660 {
661 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
662 	hda_nid_t nid = kcontrol->private_value & 0xffff;
663 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
664 	long *valp = ucontrol->value.integer.value;
665 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
666 					      AC_VERB_GET_GPIO_DATA, 0x00);
667 
668 	*valp = (val & mask) != 0;
669 	return 0;
670 }
671 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
672 			     struct snd_ctl_elem_value *ucontrol)
673 {
674 	signed int change;
675 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
676 	hda_nid_t nid = kcontrol->private_value & 0xffff;
677 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
678 	long val = *ucontrol->value.integer.value;
679 	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
680 						    AC_VERB_GET_GPIO_DATA,
681 						    0x00);
682 
683 	/* Set/unset the masked GPIO bit(s) as needed */
684 	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
685 	if (val == 0)
686 		gpio_data &= ~mask;
687 	else
688 		gpio_data |= mask;
689 	snd_hda_codec_write_cache(codec, nid, 0,
690 				  AC_VERB_SET_GPIO_DATA, gpio_data);
691 
692 	return change;
693 }
694 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
695 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
696 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
697 	  .info = alc_gpio_data_info, \
698 	  .get = alc_gpio_data_get, \
699 	  .put = alc_gpio_data_put, \
700 	  .private_value = nid | (mask<<16) }
701 #endif   /* CONFIG_SND_DEBUG */
702 
703 /* A switch control to allow the enabling of the digital IO pins on the
704  * ALC260.  This is incredibly simplistic; the intention of this control is
705  * to provide something in the test model allowing digital outputs to be
706  * identified if present.  If models are found which can utilise these
707  * outputs a more complete mixer control can be devised for those models if
708  * necessary.
709  */
710 #ifdef CONFIG_SND_DEBUG
711 #define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info
712 
713 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
714 			      struct snd_ctl_elem_value *ucontrol)
715 {
716 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
717 	hda_nid_t nid = kcontrol->private_value & 0xffff;
718 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
719 	long *valp = ucontrol->value.integer.value;
720 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
721 					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);
722 
723 	*valp = (val & mask) != 0;
724 	return 0;
725 }
726 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
727 			      struct snd_ctl_elem_value *ucontrol)
728 {
729 	signed int change;
730 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
731 	hda_nid_t nid = kcontrol->private_value & 0xffff;
732 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
733 	long val = *ucontrol->value.integer.value;
734 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
735 						    AC_VERB_GET_DIGI_CONVERT_1,
736 						    0x00);
737 
738 	/* Set/unset the masked control bit(s) as needed */
739 	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
740 	if (val==0)
741 		ctrl_data &= ~mask;
742 	else
743 		ctrl_data |= mask;
744 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
745 				  ctrl_data);
746 
747 	return change;
748 }
749 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
750 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
751 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
752 	  .info = alc_spdif_ctrl_info, \
753 	  .get = alc_spdif_ctrl_get, \
754 	  .put = alc_spdif_ctrl_put, \
755 	  .private_value = nid | (mask<<16) }
756 #endif   /* CONFIG_SND_DEBUG */
757 
758 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
759  * Again, this is only used in the ALC26x test models to help identify when
760  * the EAPD line must be asserted for features to work.
761  */
762 #ifdef CONFIG_SND_DEBUG
763 #define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info
764 
765 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
766 			      struct snd_ctl_elem_value *ucontrol)
767 {
768 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
769 	hda_nid_t nid = kcontrol->private_value & 0xffff;
770 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
771 	long *valp = ucontrol->value.integer.value;
772 	unsigned int val = snd_hda_codec_read(codec, nid, 0,
773 					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);
774 
775 	*valp = (val & mask) != 0;
776 	return 0;
777 }
778 
779 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
780 			      struct snd_ctl_elem_value *ucontrol)
781 {
782 	int change;
783 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
784 	hda_nid_t nid = kcontrol->private_value & 0xffff;
785 	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
786 	long val = *ucontrol->value.integer.value;
787 	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
788 						    AC_VERB_GET_EAPD_BTLENABLE,
789 						    0x00);
790 
791 	/* Set/unset the masked control bit(s) as needed */
792 	change = (!val ? 0 : mask) != (ctrl_data & mask);
793 	if (!val)
794 		ctrl_data &= ~mask;
795 	else
796 		ctrl_data |= mask;
797 	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
798 				  ctrl_data);
799 
800 	return change;
801 }
802 
803 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
804 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
805 	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
806 	  .info = alc_eapd_ctrl_info, \
807 	  .get = alc_eapd_ctrl_get, \
808 	  .put = alc_eapd_ctrl_put, \
809 	  .private_value = nid | (mask<<16) }
810 #endif   /* CONFIG_SND_DEBUG */
811 
812 /*
813  * set up the input pin config (depending on the given auto-pin type)
814  */
815 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
816 			      int auto_pin_type)
817 {
818 	unsigned int val = PIN_IN;
819 
820 	if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
821 		unsigned int pincap;
822 		pincap = snd_hda_query_pin_caps(codec, nid);
823 		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
824 		if (pincap & AC_PINCAP_VREF_80)
825 			val = PIN_VREF80;
826 		else if (pincap & AC_PINCAP_VREF_50)
827 			val = PIN_VREF50;
828 		else if (pincap & AC_PINCAP_VREF_100)
829 			val = PIN_VREF100;
830 		else if (pincap & AC_PINCAP_VREF_GRD)
831 			val = PIN_VREFGRD;
832 	}
833 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
834 }
835 
836 /*
837  */
838 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
839 {
840 	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
841 		return;
842 	spec->mixers[spec->num_mixers++] = mix;
843 }
844 
845 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
846 {
847 	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
848 		return;
849 	spec->init_verbs[spec->num_init_verbs++] = verb;
850 }
851 
852 /*
853  * set up from the preset table
854  */
855 static void setup_preset(struct hda_codec *codec,
856 			 const struct alc_config_preset *preset)
857 {
858 	struct alc_spec *spec = codec->spec;
859 	int i;
860 
861 	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
862 		add_mixer(spec, preset->mixers[i]);
863 	spec->cap_mixer = preset->cap_mixer;
864 	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
865 	     i++)
866 		add_verb(spec, preset->init_verbs[i]);
867 
868 	spec->channel_mode = preset->channel_mode;
869 	spec->num_channel_mode = preset->num_channel_mode;
870 	spec->need_dac_fix = preset->need_dac_fix;
871 	spec->const_channel_count = preset->const_channel_count;
872 
873 	if (preset->const_channel_count)
874 		spec->multiout.max_channels = preset->const_channel_count;
875 	else
876 		spec->multiout.max_channels = spec->channel_mode[0].channels;
877 	spec->ext_channel_count = spec->channel_mode[0].channels;
878 
879 	spec->multiout.num_dacs = preset->num_dacs;
880 	spec->multiout.dac_nids = preset->dac_nids;
881 	spec->multiout.dig_out_nid = preset->dig_out_nid;
882 	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
883 	spec->multiout.hp_nid = preset->hp_nid;
884 
885 	spec->num_mux_defs = preset->num_mux_defs;
886 	if (!spec->num_mux_defs)
887 		spec->num_mux_defs = 1;
888 	spec->input_mux = preset->input_mux;
889 
890 	spec->num_adc_nids = preset->num_adc_nids;
891 	spec->adc_nids = preset->adc_nids;
892 	spec->capsrc_nids = preset->capsrc_nids;
893 	spec->dig_in_nid = preset->dig_in_nid;
894 
895 	spec->unsol_event = preset->unsol_event;
896 	spec->init_hook = preset->init_hook;
897 #ifdef CONFIG_SND_HDA_POWER_SAVE
898 	spec->power_hook = preset->power_hook;
899 	spec->loopback.amplist = preset->loopbacks;
900 #endif
901 
902 	if (preset->setup)
903 		preset->setup(codec);
904 }
905 
906 /* Enable GPIO mask and set output */
907 static struct hda_verb alc_gpio1_init_verbs[] = {
908 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
909 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
910 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
911 	{ }
912 };
913 
914 static struct hda_verb alc_gpio2_init_verbs[] = {
915 	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
916 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
917 	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
918 	{ }
919 };
920 
921 static struct hda_verb alc_gpio3_init_verbs[] = {
922 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
923 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
924 	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
925 	{ }
926 };
927 
928 /*
929  * Fix hardware PLL issue
930  * On some codecs, the analog PLL gating control must be off while
931  * the default value is 1.
932  */
933 static void alc_fix_pll(struct hda_codec *codec)
934 {
935 	struct alc_spec *spec = codec->spec;
936 	unsigned int val;
937 
938 	if (!spec->pll_nid)
939 		return;
940 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
941 			    spec->pll_coef_idx);
942 	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
943 				 AC_VERB_GET_PROC_COEF, 0);
944 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
945 			    spec->pll_coef_idx);
946 	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
947 			    val & ~(1 << spec->pll_coef_bit));
948 }
949 
950 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
951 			     unsigned int coef_idx, unsigned int coef_bit)
952 {
953 	struct alc_spec *spec = codec->spec;
954 	spec->pll_nid = nid;
955 	spec->pll_coef_idx = coef_idx;
956 	spec->pll_coef_bit = coef_bit;
957 	alc_fix_pll(codec);
958 }
959 
960 static void alc_automute_pin(struct hda_codec *codec)
961 {
962 	struct alc_spec *spec = codec->spec;
963 	unsigned int nid = spec->autocfg.hp_pins[0];
964 	int i;
965 
966 	if (!nid)
967 		return;
968 	spec->jack_present = snd_hda_jack_detect(codec, nid);
969 	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
970 		nid = spec->autocfg.speaker_pins[i];
971 		if (!nid)
972 			break;
973 		snd_hda_codec_write(codec, nid, 0,
974 				    AC_VERB_SET_PIN_WIDGET_CONTROL,
975 				    spec->jack_present ? 0 : PIN_OUT);
976 	}
977 }
978 
979 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
980 				hda_nid_t nid)
981 {
982 	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
983 	int i, nums;
984 
985 	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
986 	for (i = 0; i < nums; i++)
987 		if (conn[i] == nid)
988 			return i;
989 	return -1;
990 }
991 
992 static void alc_mic_automute(struct hda_codec *codec)
993 {
994 	struct alc_spec *spec = codec->spec;
995 	struct alc_mic_route *dead, *alive;
996 	unsigned int present, type;
997 	hda_nid_t cap_nid;
998 
999 	if (!spec->auto_mic)
1000 		return;
1001 	if (!spec->int_mic.pin || !spec->ext_mic.pin)
1002 		return;
1003 	if (snd_BUG_ON(!spec->adc_nids))
1004 		return;
1005 
1006 	cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1007 
1008 	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1009 	if (present) {
1010 		alive = &spec->ext_mic;
1011 		dead = &spec->int_mic;
1012 	} else {
1013 		alive = &spec->int_mic;
1014 		dead = &spec->ext_mic;
1015 	}
1016 
1017 	type = get_wcaps_type(get_wcaps(codec, cap_nid));
1018 	if (type == AC_WID_AUD_MIX) {
1019 		/* Matrix-mixer style (e.g. ALC882) */
1020 		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1021 					 alive->mux_idx,
1022 					 HDA_AMP_MUTE, 0);
1023 		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1024 					 dead->mux_idx,
1025 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
1026 	} else {
1027 		/* MUX style (e.g. ALC880) */
1028 		snd_hda_codec_write_cache(codec, cap_nid, 0,
1029 					  AC_VERB_SET_CONNECT_SEL,
1030 					  alive->mux_idx);
1031 	}
1032 
1033 	/* FIXME: analog mixer */
1034 }
1035 
1036 /* unsolicited event for HP jack sensing */
1037 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1038 {
1039 	if (codec->vendor_id == 0x10ec0880)
1040 		res >>= 28;
1041 	else
1042 		res >>= 26;
1043 	switch (res) {
1044 	case ALC880_HP_EVENT:
1045 		alc_automute_pin(codec);
1046 		break;
1047 	case ALC880_MIC_EVENT:
1048 		alc_mic_automute(codec);
1049 		break;
1050 	}
1051 }
1052 
1053 static void alc_inithook(struct hda_codec *codec)
1054 {
1055 	alc_automute_pin(codec);
1056 	alc_mic_automute(codec);
1057 }
1058 
1059 /* additional initialization for ALC888 variants */
1060 static void alc888_coef_init(struct hda_codec *codec)
1061 {
1062 	unsigned int tmp;
1063 
1064 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1065 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1066 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1067 	if ((tmp & 0xf0) == 0x20)
1068 		/* alc888S-VC */
1069 		snd_hda_codec_read(codec, 0x20, 0,
1070 				   AC_VERB_SET_PROC_COEF, 0x830);
1071 	 else
1072 		 /* alc888-VB */
1073 		 snd_hda_codec_read(codec, 0x20, 0,
1074 				    AC_VERB_SET_PROC_COEF, 0x3030);
1075 }
1076 
1077 static void alc889_coef_init(struct hda_codec *codec)
1078 {
1079 	unsigned int tmp;
1080 
1081 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1082 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1083 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1084 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1085 }
1086 
1087 /* turn on/off EAPD control (only if available) */
1088 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1089 {
1090 	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1091 		return;
1092 	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1093 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1094 				    on ? 2 : 0);
1095 }
1096 
1097 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1098 {
1099 	unsigned int tmp;
1100 
1101 	switch (type) {
1102 	case ALC_INIT_GPIO1:
1103 		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1104 		break;
1105 	case ALC_INIT_GPIO2:
1106 		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1107 		break;
1108 	case ALC_INIT_GPIO3:
1109 		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1110 		break;
1111 	case ALC_INIT_DEFAULT:
1112 		switch (codec->vendor_id) {
1113 		case 0x10ec0260:
1114 			set_eapd(codec, 0x0f, 1);
1115 			set_eapd(codec, 0x10, 1);
1116 			break;
1117 		case 0x10ec0262:
1118 		case 0x10ec0267:
1119 		case 0x10ec0268:
1120 		case 0x10ec0269:
1121 		case 0x10ec0270:
1122 		case 0x10ec0272:
1123 		case 0x10ec0660:
1124 		case 0x10ec0662:
1125 		case 0x10ec0663:
1126 		case 0x10ec0862:
1127 		case 0x10ec0889:
1128 			set_eapd(codec, 0x14, 1);
1129 			set_eapd(codec, 0x15, 1);
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 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1157 		case 0x10ec0267:
1158 		case 0x10ec0268:
1159 			snd_hda_codec_write(codec, 0x20, 0,
1160 					    AC_VERB_SET_COEF_INDEX, 7);
1161 			tmp = snd_hda_codec_read(codec, 0x20, 0,
1162 						 AC_VERB_GET_PROC_COEF, 0);
1163 			snd_hda_codec_write(codec, 0x20, 0,
1164 					    AC_VERB_SET_COEF_INDEX, 7);
1165 			snd_hda_codec_write(codec, 0x20, 0,
1166 					    AC_VERB_SET_PROC_COEF,
1167 					    tmp | 0x3000);
1168 			break;
1169 #endif /* XXX */
1170 		}
1171 		break;
1172 	}
1173 }
1174 
1175 static void alc_init_auto_hp(struct hda_codec *codec)
1176 {
1177 	struct alc_spec *spec = codec->spec;
1178 
1179 	if (!spec->autocfg.hp_pins[0])
1180 		return;
1181 
1182 	if (!spec->autocfg.speaker_pins[0]) {
1183 		if (spec->autocfg.line_out_pins[0] &&
1184 		    spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1185 			spec->autocfg.speaker_pins[0] =
1186 				spec->autocfg.line_out_pins[0];
1187 		else
1188 			return;
1189 	}
1190 
1191 	snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1192 		    spec->autocfg.hp_pins[0]);
1193 	snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1194 				  AC_VERB_SET_UNSOLICITED_ENABLE,
1195 				  AC_USRSP_EN | ALC880_HP_EVENT);
1196 	spec->unsol_event = alc_sku_unsol_event;
1197 }
1198 
1199 static void alc_init_auto_mic(struct hda_codec *codec)
1200 {
1201 	struct alc_spec *spec = codec->spec;
1202 	struct auto_pin_cfg *cfg = &spec->autocfg;
1203 	hda_nid_t fixed, ext;
1204 	int i;
1205 
1206 	/* there must be only two mic inputs exclusively */
1207 	for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1208 		if (cfg->input_pins[i])
1209 			return;
1210 
1211 	fixed = ext = 0;
1212 	for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1213 		hda_nid_t nid = cfg->input_pins[i];
1214 		unsigned int defcfg;
1215 		if (!nid)
1216 			return;
1217 		defcfg = snd_hda_codec_get_pincfg(codec, nid);
1218 		switch (get_defcfg_connect(defcfg)) {
1219 		case AC_JACK_PORT_FIXED:
1220 			if (fixed)
1221 				return; /* already occupied */
1222 			fixed = nid;
1223 			break;
1224 		case AC_JACK_PORT_COMPLEX:
1225 			if (ext)
1226 				return; /* already occupied */
1227 			ext = nid;
1228 			break;
1229 		default:
1230 			return; /* invalid entry */
1231 		}
1232 	}
1233 	if (!ext || !fixed)
1234 		return;
1235 	if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1236 		return; /* no unsol support */
1237 	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1238 		    ext, fixed);
1239 	spec->ext_mic.pin = ext;
1240 	spec->int_mic.pin = fixed;
1241 	spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1242 	spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1243 	spec->auto_mic = 1;
1244 	snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1245 				  AC_VERB_SET_UNSOLICITED_ENABLE,
1246 				  AC_USRSP_EN | ALC880_MIC_EVENT);
1247 	spec->unsol_event = alc_sku_unsol_event;
1248 }
1249 
1250 /* check subsystem ID and set up device-specific initialization;
1251  * return 1 if initialized, 0 if invalid SSID
1252  */
1253 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1254  *	31 ~ 16 :	Manufacture ID
1255  *	15 ~ 8	:	SKU ID
1256  *	7  ~ 0	:	Assembly ID
1257  *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1258  */
1259 static int alc_subsystem_id(struct hda_codec *codec,
1260 			    hda_nid_t porta, hda_nid_t porte,
1261 			    hda_nid_t portd, hda_nid_t porti)
1262 {
1263 	unsigned int ass, tmp, i;
1264 	unsigned nid;
1265 	struct alc_spec *spec = codec->spec;
1266 
1267 	ass = codec->subsystem_id & 0xffff;
1268 	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1269 		goto do_sku;
1270 
1271 	/* invalid SSID, check the special NID pin defcfg instead */
1272 	/*
1273 	 * 31~30	: port connectivity
1274 	 * 29~21	: reserve
1275 	 * 20		: PCBEEP input
1276 	 * 19~16	: Check sum (15:1)
1277 	 * 15~1		: Custom
1278 	 * 0		: override
1279 	*/
1280 	nid = 0x1d;
1281 	if (codec->vendor_id == 0x10ec0260)
1282 		nid = 0x17;
1283 	ass = snd_hda_codec_get_pincfg(codec, nid);
1284 	snd_printd("realtek: No valid SSID, "
1285 		   "checking pincfg 0x%08x for NID 0x%x\n",
1286 		   ass, nid);
1287 	if (!(ass & 1))
1288 		return 0;
1289 	if ((ass >> 30) != 1)	/* no physical connection */
1290 		return 0;
1291 
1292 	/* check sum */
1293 	tmp = 0;
1294 	for (i = 1; i < 16; i++) {
1295 		if ((ass >> i) & 1)
1296 			tmp++;
1297 	}
1298 	if (((ass >> 16) & 0xf) != tmp)
1299 		return 0;
1300 do_sku:
1301 	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1302 		   ass & 0xffff, codec->vendor_id);
1303 	/*
1304 	 * 0 : override
1305 	 * 1 :	Swap Jack
1306 	 * 2 : 0 --> Desktop, 1 --> Laptop
1307 	 * 3~5 : External Amplifier control
1308 	 * 7~6 : Reserved
1309 	*/
1310 	tmp = (ass & 0x38) >> 3;	/* external Amp control */
1311 	switch (tmp) {
1312 	case 1:
1313 		spec->init_amp = ALC_INIT_GPIO1;
1314 		break;
1315 	case 3:
1316 		spec->init_amp = ALC_INIT_GPIO2;
1317 		break;
1318 	case 7:
1319 		spec->init_amp = ALC_INIT_GPIO3;
1320 		break;
1321 	case 5:
1322 		spec->init_amp = ALC_INIT_DEFAULT;
1323 		break;
1324 	}
1325 
1326 	/* is laptop or Desktop and enable the function "Mute internal speaker
1327 	 * when the external headphone out jack is plugged"
1328 	 */
1329 	if (!(ass & 0x8000))
1330 		return 1;
1331 	/*
1332 	 * 10~8 : Jack location
1333 	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1334 	 * 14~13: Resvered
1335 	 * 15   : 1 --> enable the function "Mute internal speaker
1336 	 *	        when the external headphone out jack is plugged"
1337 	 */
1338 	if (!spec->autocfg.hp_pins[0]) {
1339 		hda_nid_t nid;
1340 		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
1341 		if (tmp == 0)
1342 			nid = porta;
1343 		else if (tmp == 1)
1344 			nid = porte;
1345 		else if (tmp == 2)
1346 			nid = portd;
1347 		else if (tmp == 3)
1348 			nid = porti;
1349 		else
1350 			return 1;
1351 		for (i = 0; i < spec->autocfg.line_outs; i++)
1352 			if (spec->autocfg.line_out_pins[i] == nid)
1353 				return 1;
1354 		spec->autocfg.hp_pins[0] = nid;
1355 	}
1356 
1357 	alc_init_auto_hp(codec);
1358 	alc_init_auto_mic(codec);
1359 	return 1;
1360 }
1361 
1362 static void alc_ssid_check(struct hda_codec *codec,
1363 			   hda_nid_t porta, hda_nid_t porte,
1364 			   hda_nid_t portd, hda_nid_t porti)
1365 {
1366 	if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1367 		struct alc_spec *spec = codec->spec;
1368 		snd_printd("realtek: "
1369 			   "Enable default setup for auto mode as fallback\n");
1370 		spec->init_amp = ALC_INIT_DEFAULT;
1371 		alc_init_auto_hp(codec);
1372 		alc_init_auto_mic(codec);
1373 	}
1374 }
1375 
1376 /*
1377  * Fix-up pin default configurations and add default verbs
1378  */
1379 
1380 struct alc_pincfg {
1381 	hda_nid_t nid;
1382 	u32 val;
1383 };
1384 
1385 struct alc_fixup {
1386 	const struct alc_pincfg *pins;
1387 	const struct hda_verb *verbs;
1388 };
1389 
1390 static void alc_pick_fixup(struct hda_codec *codec,
1391 			   const struct snd_pci_quirk *quirk,
1392 			   const struct alc_fixup *fix)
1393 {
1394 	const struct alc_pincfg *cfg;
1395 
1396 	quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1397 	if (!quirk)
1398 		return;
1399 
1400 	fix += quirk->value;
1401 	cfg = fix->pins;
1402 	if (cfg) {
1403 		for (; cfg->nid; cfg++)
1404 			snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1405 	}
1406 	if (fix->verbs)
1407 		add_verb(codec->spec, fix->verbs);
1408 }
1409 
1410 static int alc_read_coef_idx(struct hda_codec *codec,
1411 			unsigned int coef_idx)
1412 {
1413 	unsigned int val;
1414 	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1415 		    		coef_idx);
1416 	val = snd_hda_codec_read(codec, 0x20, 0,
1417 			 	AC_VERB_GET_PROC_COEF, 0);
1418 	return val;
1419 }
1420 
1421 /*
1422  * ALC888
1423  */
1424 
1425 /*
1426  * 2ch mode
1427  */
1428 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1429 /* Mic-in jack as mic in */
1430 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1431 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1432 /* Line-in jack as Line in */
1433 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1434 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1435 /* Line-Out as Front */
1436 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1437 	{ } /* end */
1438 };
1439 
1440 /*
1441  * 4ch mode
1442  */
1443 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1444 /* Mic-in jack as mic in */
1445 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1446 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1447 /* Line-in jack as Surround */
1448 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1449 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1450 /* Line-Out as Front */
1451 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1452 	{ } /* end */
1453 };
1454 
1455 /*
1456  * 6ch mode
1457  */
1458 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1459 /* Mic-in jack as CLFE */
1460 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1461 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1462 /* Line-in jack as Surround */
1463 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1464 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1465 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1466 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1467 	{ } /* end */
1468 };
1469 
1470 /*
1471  * 8ch mode
1472  */
1473 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1474 /* Mic-in jack as CLFE */
1475 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1476 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1477 /* Line-in jack as Surround */
1478 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1479 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1480 /* Line-Out as Side */
1481 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1482 	{ } /* end */
1483 };
1484 
1485 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1486 	{ 2, alc888_4ST_ch2_intel_init },
1487 	{ 4, alc888_4ST_ch4_intel_init },
1488 	{ 6, alc888_4ST_ch6_intel_init },
1489 	{ 8, alc888_4ST_ch8_intel_init },
1490 };
1491 
1492 /*
1493  * ALC888 Fujitsu Siemens Amillo xa3530
1494  */
1495 
1496 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1497 /* Front Mic: set to PIN_IN (empty by default) */
1498 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1499 /* Connect Internal HP to Front */
1500 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1501 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1502 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1503 /* Connect Bass HP to Front */
1504 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1505 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1506 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1507 /* Connect Line-Out side jack (SPDIF) to Side */
1508 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1509 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1510 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1511 /* Connect Mic jack to CLFE */
1512 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1513 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1514 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1515 /* Connect Line-in jack to Surround */
1516 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1517 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1518 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1519 /* Connect HP out jack to Front */
1520 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1521 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1522 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1523 /* Enable unsolicited event for HP jack and Line-out jack */
1524 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1525 	{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1526 	{}
1527 };
1528 
1529 static void alc_automute_amp(struct hda_codec *codec)
1530 {
1531 	struct alc_spec *spec = codec->spec;
1532 	unsigned int mute;
1533 	hda_nid_t nid;
1534 	int i;
1535 
1536 	spec->jack_present = 0;
1537 	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1538 		nid = spec->autocfg.hp_pins[i];
1539 		if (!nid)
1540 			break;
1541 		if (snd_hda_jack_detect(codec, nid)) {
1542 			spec->jack_present = 1;
1543 			break;
1544 		}
1545 	}
1546 
1547 	mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1548 	/* Toggle internal speakers muting */
1549 	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1550 		nid = spec->autocfg.speaker_pins[i];
1551 		if (!nid)
1552 			break;
1553 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1554 					 HDA_AMP_MUTE, mute);
1555 	}
1556 }
1557 
1558 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1559 					 unsigned int res)
1560 {
1561 	if (codec->vendor_id == 0x10ec0880)
1562 		res >>= 28;
1563 	else
1564 		res >>= 26;
1565 	if (res == ALC880_HP_EVENT)
1566 		alc_automute_amp(codec);
1567 }
1568 
1569 static void alc889_automute_setup(struct hda_codec *codec)
1570 {
1571 	struct alc_spec *spec = codec->spec;
1572 
1573 	spec->autocfg.hp_pins[0] = 0x15;
1574 	spec->autocfg.speaker_pins[0] = 0x14;
1575 	spec->autocfg.speaker_pins[1] = 0x16;
1576 	spec->autocfg.speaker_pins[2] = 0x17;
1577 	spec->autocfg.speaker_pins[3] = 0x19;
1578 	spec->autocfg.speaker_pins[4] = 0x1a;
1579 }
1580 
1581 static void alc889_intel_init_hook(struct hda_codec *codec)
1582 {
1583 	alc889_coef_init(codec);
1584 	alc_automute_amp(codec);
1585 }
1586 
1587 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1588 {
1589 	struct alc_spec *spec = codec->spec;
1590 
1591 	spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1592 	spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1593 	spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1594 	spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1595 }
1596 
1597 /*
1598  * ALC888 Acer Aspire 4930G model
1599  */
1600 
1601 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1602 /* Front Mic: set to PIN_IN (empty by default) */
1603 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1604 /* Unselect Front Mic by default in input mixer 3 */
1605 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1606 /* Enable unsolicited event for HP jack */
1607 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1608 /* Connect Internal HP to front */
1609 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1610 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1611 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1612 /* Connect HP out to front */
1613 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1614 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1615 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1616 	{ }
1617 };
1618 
1619 /*
1620  * ALC888 Acer Aspire 6530G model
1621  */
1622 
1623 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1624 /* Route to built-in subwoofer as well as speakers */
1625 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1626 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1627 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1628 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1629 /* Bias voltage on for external mic port */
1630 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1631 /* Front Mic: set to PIN_IN (empty by default) */
1632 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1633 /* Unselect Front Mic by default in input mixer 3 */
1634 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1635 /* Enable unsolicited event for HP jack */
1636 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1637 /* Enable speaker output */
1638 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1639 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1640 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
1641 /* Enable headphone output */
1642 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1643 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1644 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1645 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
1646 	{ }
1647 };
1648 
1649 /*
1650  * ALC889 Acer Aspire 8930G model
1651  */
1652 
1653 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1654 /* Front Mic: set to PIN_IN (empty by default) */
1655 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1656 /* Unselect Front Mic by default in input mixer 3 */
1657 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1658 /* Enable unsolicited event for HP jack */
1659 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1660 /* Connect Internal Front to Front */
1661 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1662 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1663 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1664 /* Connect Internal Rear to Rear */
1665 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1666 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1667 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1668 /* Connect Internal CLFE to CLFE */
1669 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1670 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1671 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1672 /* Connect HP out to Front */
1673 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1674 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1675 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1676 /* Enable all DACs */
1677 /*  DAC DISABLE/MUTE 1? */
1678 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1679 	{0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1680 	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1681 /*  DAC DISABLE/MUTE 2? */
1682 /*  some bit here disables the other DACs. Init=0x4900 */
1683 	{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1684 	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1685 /* DMIC fix
1686  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1687  * which makes the stereo useless. However, either the mic or the ALC889
1688  * makes the signal become a difference/sum signal instead of standard
1689  * stereo, which is annoying. So instead we flip this bit which makes the
1690  * codec replicate the sum signal to both channels, turning it into a
1691  * normal mono mic.
1692  */
1693 /*  DMIC_CONTROL? Init value = 0x0001 */
1694 	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1695 	{0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1696 	{ }
1697 };
1698 
1699 static struct hda_input_mux alc888_2_capture_sources[2] = {
1700 	/* Front mic only available on one ADC */
1701 	{
1702 		.num_items = 4,
1703 		.items = {
1704 			{ "Mic", 0x0 },
1705 			{ "Line", 0x2 },
1706 			{ "CD", 0x4 },
1707 			{ "Front Mic", 0xb },
1708 		},
1709 	},
1710 	{
1711 		.num_items = 3,
1712 		.items = {
1713 			{ "Mic", 0x0 },
1714 			{ "Line", 0x2 },
1715 			{ "CD", 0x4 },
1716 		},
1717 	}
1718 };
1719 
1720 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1721 	/* Interal mic only available on one ADC */
1722 	{
1723 		.num_items = 5,
1724 		.items = {
1725 			{ "Ext Mic", 0x0 },
1726 			{ "Line In", 0x2 },
1727 			{ "CD", 0x4 },
1728 			{ "Input Mix", 0xa },
1729 			{ "Int Mic", 0xb },
1730 		},
1731 	},
1732 	{
1733 		.num_items = 4,
1734 		.items = {
1735 			{ "Ext Mic", 0x0 },
1736 			{ "Line In", 0x2 },
1737 			{ "CD", 0x4 },
1738 			{ "Input Mix", 0xa },
1739 		},
1740 	}
1741 };
1742 
1743 static struct hda_input_mux alc889_capture_sources[3] = {
1744 	/* Digital mic only available on first "ADC" */
1745 	{
1746 		.num_items = 5,
1747 		.items = {
1748 			{ "Mic", 0x0 },
1749 			{ "Line", 0x2 },
1750 			{ "CD", 0x4 },
1751 			{ "Front Mic", 0xb },
1752 			{ "Input Mix", 0xa },
1753 		},
1754 	},
1755 	{
1756 		.num_items = 4,
1757 		.items = {
1758 			{ "Mic", 0x0 },
1759 			{ "Line", 0x2 },
1760 			{ "CD", 0x4 },
1761 			{ "Input Mix", 0xa },
1762 		},
1763 	},
1764 	{
1765 		.num_items = 4,
1766 		.items = {
1767 			{ "Mic", 0x0 },
1768 			{ "Line", 0x2 },
1769 			{ "CD", 0x4 },
1770 			{ "Input Mix", 0xa },
1771 		},
1772 	}
1773 };
1774 
1775 static struct snd_kcontrol_new alc888_base_mixer[] = {
1776 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1777 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1778 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1779 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1780 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1781 		HDA_OUTPUT),
1782 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1783 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1784 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1785 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1786 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1787 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1788 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1789 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1790 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1791 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1792 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1793 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1794 	{ } /* end */
1795 };
1796 
1797 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1798 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1799 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1800 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1801 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1802 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1803 		HDA_OUTPUT),
1804 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1805 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1806 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1807 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1808 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1809 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1810 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1811 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1812 	{ } /* end */
1813 };
1814 
1815 
1816 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1817 {
1818 	struct alc_spec *spec = codec->spec;
1819 
1820 	spec->autocfg.hp_pins[0] = 0x15;
1821 	spec->autocfg.speaker_pins[0] = 0x14;
1822 	spec->autocfg.speaker_pins[1] = 0x16;
1823 	spec->autocfg.speaker_pins[2] = 0x17;
1824 }
1825 
1826 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1827 {
1828 	struct alc_spec *spec = codec->spec;
1829 
1830 	spec->autocfg.hp_pins[0] = 0x15;
1831 	spec->autocfg.speaker_pins[0] = 0x14;
1832 	spec->autocfg.speaker_pins[1] = 0x16;
1833 	spec->autocfg.speaker_pins[2] = 0x17;
1834 }
1835 
1836 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1837 {
1838 	struct alc_spec *spec = codec->spec;
1839 
1840 	spec->autocfg.hp_pins[0] = 0x15;
1841 	spec->autocfg.speaker_pins[0] = 0x14;
1842 	spec->autocfg.speaker_pins[1] = 0x16;
1843 	spec->autocfg.speaker_pins[2] = 0x1b;
1844 }
1845 
1846 /*
1847  * ALC880 3-stack model
1848  *
1849  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1850  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1851  *                 F-Mic = 0x1b, HP = 0x19
1852  */
1853 
1854 static hda_nid_t alc880_dac_nids[4] = {
1855 	/* front, rear, clfe, rear_surr */
1856 	0x02, 0x05, 0x04, 0x03
1857 };
1858 
1859 static hda_nid_t alc880_adc_nids[3] = {
1860 	/* ADC0-2 */
1861 	0x07, 0x08, 0x09,
1862 };
1863 
1864 /* The datasheet says the node 0x07 is connected from inputs,
1865  * but it shows zero connection in the real implementation on some devices.
1866  * Note: this is a 915GAV bug, fixed on 915GLV
1867  */
1868 static hda_nid_t alc880_adc_nids_alt[2] = {
1869 	/* ADC1-2 */
1870 	0x08, 0x09,
1871 };
1872 
1873 #define ALC880_DIGOUT_NID	0x06
1874 #define ALC880_DIGIN_NID	0x0a
1875 
1876 static struct hda_input_mux alc880_capture_source = {
1877 	.num_items = 4,
1878 	.items = {
1879 		{ "Mic", 0x0 },
1880 		{ "Front Mic", 0x3 },
1881 		{ "Line", 0x2 },
1882 		{ "CD", 0x4 },
1883 	},
1884 };
1885 
1886 /* channel source setting (2/6 channel selection for 3-stack) */
1887 /* 2ch mode */
1888 static struct hda_verb alc880_threestack_ch2_init[] = {
1889 	/* set line-in to input, mute it */
1890 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1891 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1892 	/* set mic-in to input vref 80%, mute it */
1893 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1894 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1895 	{ } /* end */
1896 };
1897 
1898 /* 6ch mode */
1899 static struct hda_verb alc880_threestack_ch6_init[] = {
1900 	/* set line-in to output, unmute it */
1901 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1902 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1903 	/* set mic-in to output, unmute it */
1904 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1905 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1906 	{ } /* end */
1907 };
1908 
1909 static struct hda_channel_mode alc880_threestack_modes[2] = {
1910 	{ 2, alc880_threestack_ch2_init },
1911 	{ 6, alc880_threestack_ch6_init },
1912 };
1913 
1914 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1915 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1916 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1917 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1918 	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1919 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1920 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1921 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1922 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1923 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1924 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1925 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1926 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1927 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1928 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1929 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1930 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1931 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1932 	{
1933 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1934 		.name = "Channel Mode",
1935 		.info = alc_ch_mode_info,
1936 		.get = alc_ch_mode_get,
1937 		.put = alc_ch_mode_put,
1938 	},
1939 	{ } /* end */
1940 };
1941 
1942 /* capture mixer elements */
1943 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1944 			    struct snd_ctl_elem_info *uinfo)
1945 {
1946 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1947 	struct alc_spec *spec = codec->spec;
1948 	int err;
1949 
1950 	mutex_lock(&codec->control_mutex);
1951 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1952 						      HDA_INPUT);
1953 	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1954 	mutex_unlock(&codec->control_mutex);
1955 	return err;
1956 }
1957 
1958 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1959 			   unsigned int size, unsigned int __user *tlv)
1960 {
1961 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1962 	struct alc_spec *spec = codec->spec;
1963 	int err;
1964 
1965 	mutex_lock(&codec->control_mutex);
1966 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1967 						      HDA_INPUT);
1968 	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1969 	mutex_unlock(&codec->control_mutex);
1970 	return err;
1971 }
1972 
1973 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1974 			     struct snd_ctl_elem_value *ucontrol);
1975 
1976 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1977 				 struct snd_ctl_elem_value *ucontrol,
1978 				 getput_call_t func)
1979 {
1980 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1981 	struct alc_spec *spec = codec->spec;
1982 	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1983 	int err;
1984 
1985 	mutex_lock(&codec->control_mutex);
1986 	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1987 						      3, 0, HDA_INPUT);
1988 	err = func(kcontrol, ucontrol);
1989 	mutex_unlock(&codec->control_mutex);
1990 	return err;
1991 }
1992 
1993 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1994 			   struct snd_ctl_elem_value *ucontrol)
1995 {
1996 	return alc_cap_getput_caller(kcontrol, ucontrol,
1997 				     snd_hda_mixer_amp_volume_get);
1998 }
1999 
2000 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2001 			   struct snd_ctl_elem_value *ucontrol)
2002 {
2003 	return alc_cap_getput_caller(kcontrol, ucontrol,
2004 				     snd_hda_mixer_amp_volume_put);
2005 }
2006 
2007 /* capture mixer elements */
2008 #define alc_cap_sw_info		snd_ctl_boolean_stereo_info
2009 
2010 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2011 			  struct snd_ctl_elem_value *ucontrol)
2012 {
2013 	return alc_cap_getput_caller(kcontrol, ucontrol,
2014 				     snd_hda_mixer_amp_switch_get);
2015 }
2016 
2017 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2018 			  struct snd_ctl_elem_value *ucontrol)
2019 {
2020 	return alc_cap_getput_caller(kcontrol, ucontrol,
2021 				     snd_hda_mixer_amp_switch_put);
2022 }
2023 
2024 #define _DEFINE_CAPMIX(num) \
2025 	{ \
2026 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2027 		.name = "Capture Switch", \
2028 		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2029 		.count = num, \
2030 		.info = alc_cap_sw_info, \
2031 		.get = alc_cap_sw_get, \
2032 		.put = alc_cap_sw_put, \
2033 	}, \
2034 	{ \
2035 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2036 		.name = "Capture Volume", \
2037 		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2038 			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2039 			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2040 		.count = num, \
2041 		.info = alc_cap_vol_info, \
2042 		.get = alc_cap_vol_get, \
2043 		.put = alc_cap_vol_put, \
2044 		.tlv = { .c = alc_cap_vol_tlv }, \
2045 	}
2046 
2047 #define _DEFINE_CAPSRC(num) \
2048 	{ \
2049 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2050 		/* .name = "Capture Source", */ \
2051 		.name = "Input Source", \
2052 		.count = num, \
2053 		.info = alc_mux_enum_info, \
2054 		.get = alc_mux_enum_get, \
2055 		.put = alc_mux_enum_put, \
2056 	}
2057 
2058 #define DEFINE_CAPMIX(num) \
2059 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2060 	_DEFINE_CAPMIX(num),				      \
2061 	_DEFINE_CAPSRC(num),				      \
2062 	{ } /* end */					      \
2063 }
2064 
2065 #define DEFINE_CAPMIX_NOSRC(num) \
2066 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2067 	_DEFINE_CAPMIX(num),					    \
2068 	{ } /* end */						    \
2069 }
2070 
2071 /* up to three ADCs */
2072 DEFINE_CAPMIX(1);
2073 DEFINE_CAPMIX(2);
2074 DEFINE_CAPMIX(3);
2075 DEFINE_CAPMIX_NOSRC(1);
2076 DEFINE_CAPMIX_NOSRC(2);
2077 DEFINE_CAPMIX_NOSRC(3);
2078 
2079 /*
2080  * ALC880 5-stack model
2081  *
2082  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2083  *      Side = 0x02 (0xd)
2084  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2085  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2086  */
2087 
2088 /* additional mixers to alc880_three_stack_mixer */
2089 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2090 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2091 	HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2092 	{ } /* end */
2093 };
2094 
2095 /* channel source setting (6/8 channel selection for 5-stack) */
2096 /* 6ch mode */
2097 static struct hda_verb alc880_fivestack_ch6_init[] = {
2098 	/* set line-in to input, mute it */
2099 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2100 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2101 	{ } /* end */
2102 };
2103 
2104 /* 8ch mode */
2105 static struct hda_verb alc880_fivestack_ch8_init[] = {
2106 	/* set line-in to output, unmute it */
2107 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2108 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2109 	{ } /* end */
2110 };
2111 
2112 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2113 	{ 6, alc880_fivestack_ch6_init },
2114 	{ 8, alc880_fivestack_ch8_init },
2115 };
2116 
2117 
2118 /*
2119  * ALC880 6-stack model
2120  *
2121  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2122  *      Side = 0x05 (0x0f)
2123  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2124  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2125  */
2126 
2127 static hda_nid_t alc880_6st_dac_nids[4] = {
2128 	/* front, rear, clfe, rear_surr */
2129 	0x02, 0x03, 0x04, 0x05
2130 };
2131 
2132 static struct hda_input_mux alc880_6stack_capture_source = {
2133 	.num_items = 4,
2134 	.items = {
2135 		{ "Mic", 0x0 },
2136 		{ "Front Mic", 0x1 },
2137 		{ "Line", 0x2 },
2138 		{ "CD", 0x4 },
2139 	},
2140 };
2141 
2142 /* fixed 8-channels */
2143 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2144 	{ 8, NULL },
2145 };
2146 
2147 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2148 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2149 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2150 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2151 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2152 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2153 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2154 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2155 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2156 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2157 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2158 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2159 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2160 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2161 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2162 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2163 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2164 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2165 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2166 	{
2167 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2168 		.name = "Channel Mode",
2169 		.info = alc_ch_mode_info,
2170 		.get = alc_ch_mode_get,
2171 		.put = alc_ch_mode_put,
2172 	},
2173 	{ } /* end */
2174 };
2175 
2176 
2177 /*
2178  * ALC880 W810 model
2179  *
2180  * W810 has rear IO for:
2181  * Front (DAC 02)
2182  * Surround (DAC 03)
2183  * Center/LFE (DAC 04)
2184  * Digital out (06)
2185  *
2186  * The system also has a pair of internal speakers, and a headphone jack.
2187  * These are both connected to Line2 on the codec, hence to DAC 02.
2188  *
2189  * There is a variable resistor to control the speaker or headphone
2190  * volume. This is a hardware-only device without a software API.
2191  *
2192  * Plugging headphones in will disable the internal speakers. This is
2193  * implemented in hardware, not via the driver using jack sense. In
2194  * a similar fashion, plugging into the rear socket marked "front" will
2195  * disable both the speakers and headphones.
2196  *
2197  * For input, there's a microphone jack, and an "audio in" jack.
2198  * These may not do anything useful with this driver yet, because I
2199  * haven't setup any initialization verbs for these yet...
2200  */
2201 
2202 static hda_nid_t alc880_w810_dac_nids[3] = {
2203 	/* front, rear/surround, clfe */
2204 	0x02, 0x03, 0x04
2205 };
2206 
2207 /* fixed 6 channels */
2208 static struct hda_channel_mode alc880_w810_modes[1] = {
2209 	{ 6, NULL }
2210 };
2211 
2212 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2213 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2214 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2215 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2216 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2217 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2218 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2219 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2220 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2221 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2222 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2223 	{ } /* end */
2224 };
2225 
2226 
2227 /*
2228  * Z710V model
2229  *
2230  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2231  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2232  *                 Line = 0x1a
2233  */
2234 
2235 static hda_nid_t alc880_z71v_dac_nids[1] = {
2236 	0x02
2237 };
2238 #define ALC880_Z71V_HP_DAC	0x03
2239 
2240 /* fixed 2 channels */
2241 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2242 	{ 2, NULL }
2243 };
2244 
2245 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2246 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2247 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2248 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2249 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2250 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2251 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2252 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2253 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2254 	{ } /* end */
2255 };
2256 
2257 
2258 /*
2259  * ALC880 F1734 model
2260  *
2261  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2262  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2263  */
2264 
2265 static hda_nid_t alc880_f1734_dac_nids[1] = {
2266 	0x03
2267 };
2268 #define ALC880_F1734_HP_DAC	0x02
2269 
2270 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2271 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2272 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2273 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2274 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2275 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2276 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2277 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2278 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2279 	{ } /* end */
2280 };
2281 
2282 static struct hda_input_mux alc880_f1734_capture_source = {
2283 	.num_items = 2,
2284 	.items = {
2285 		{ "Mic", 0x1 },
2286 		{ "CD", 0x4 },
2287 	},
2288 };
2289 
2290 
2291 /*
2292  * ALC880 ASUS model
2293  *
2294  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2295  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2296  *  Mic = 0x18, Line = 0x1a
2297  */
2298 
2299 #define alc880_asus_dac_nids	alc880_w810_dac_nids	/* identical with w810 */
2300 #define alc880_asus_modes	alc880_threestack_modes	/* 2/6 channel mode */
2301 
2302 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2303 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2304 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2305 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2306 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2307 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2308 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2309 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2310 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2311 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2312 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2313 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2314 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2315 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2316 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2317 	{
2318 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2319 		.name = "Channel Mode",
2320 		.info = alc_ch_mode_info,
2321 		.get = alc_ch_mode_get,
2322 		.put = alc_ch_mode_put,
2323 	},
2324 	{ } /* end */
2325 };
2326 
2327 /*
2328  * ALC880 ASUS W1V model
2329  *
2330  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2331  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2332  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2333  */
2334 
2335 /* additional mixers to alc880_asus_mixer */
2336 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2337 	HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2338 	HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2339 	{ } /* end */
2340 };
2341 
2342 /* TCL S700 */
2343 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2344 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2345 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2346 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2347 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2348 	HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2349 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2350 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2351 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2352 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2353 	{ } /* end */
2354 };
2355 
2356 /* Uniwill */
2357 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2358 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2359 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2360 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2361 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2362 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2363 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2364 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2365 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2366 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2367 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2368 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2369 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2370 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2371 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2372 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2373 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2374 	{
2375 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2376 		.name = "Channel Mode",
2377 		.info = alc_ch_mode_info,
2378 		.get = alc_ch_mode_get,
2379 		.put = alc_ch_mode_put,
2380 	},
2381 	{ } /* end */
2382 };
2383 
2384 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2385 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2386 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2387 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2388 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2389 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2390 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2391 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2392 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2393 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2394 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2395 	{ } /* end */
2396 };
2397 
2398 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2399 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2400 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2401 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2402 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2403 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2404 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2405 	{ } /* end */
2406 };
2407 
2408 /*
2409  * virtual master controls
2410  */
2411 
2412 /*
2413  * slave controls for virtual master
2414  */
2415 static const char *alc_slave_vols[] = {
2416 	"Front Playback Volume",
2417 	"Surround Playback Volume",
2418 	"Center Playback Volume",
2419 	"LFE Playback Volume",
2420 	"Side Playback Volume",
2421 	"Headphone Playback Volume",
2422 	"Speaker Playback Volume",
2423 	"Mono Playback Volume",
2424 	"Line-Out Playback Volume",
2425 	"PCM Playback Volume",
2426 	NULL,
2427 };
2428 
2429 static const char *alc_slave_sws[] = {
2430 	"Front Playback Switch",
2431 	"Surround Playback Switch",
2432 	"Center Playback Switch",
2433 	"LFE Playback Switch",
2434 	"Side Playback Switch",
2435 	"Headphone Playback Switch",
2436 	"Speaker Playback Switch",
2437 	"Mono Playback Switch",
2438 	"IEC958 Playback Switch",
2439 	"Line-Out Playback Switch",
2440 	"PCM Playback Switch",
2441 	NULL,
2442 };
2443 
2444 /*
2445  * build control elements
2446  */
2447 
2448 #define NID_MAPPING		(-1)
2449 
2450 #define SUBDEV_SPEAKER_		(0 << 6)
2451 #define SUBDEV_HP_		(1 << 6)
2452 #define SUBDEV_LINE_		(2 << 6)
2453 #define SUBDEV_SPEAKER(x)	(SUBDEV_SPEAKER_ | ((x) & 0x3f))
2454 #define SUBDEV_HP(x)		(SUBDEV_HP_ | ((x) & 0x3f))
2455 #define SUBDEV_LINE(x)		(SUBDEV_LINE_ | ((x) & 0x3f))
2456 
2457 static void alc_free_kctls(struct hda_codec *codec);
2458 
2459 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2460 /* additional beep mixers; the actual parameters are overwritten at build */
2461 static struct snd_kcontrol_new alc_beep_mixer[] = {
2462 	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2463 	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2464 	{ } /* end */
2465 };
2466 #endif
2467 
2468 static int alc_build_controls(struct hda_codec *codec)
2469 {
2470 	struct alc_spec *spec = codec->spec;
2471 	struct snd_kcontrol *kctl;
2472 	struct snd_kcontrol_new *knew;
2473 	int i, j, err;
2474 	unsigned int u;
2475 	hda_nid_t nid;
2476 
2477 	for (i = 0; i < spec->num_mixers; i++) {
2478 		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2479 		if (err < 0)
2480 			return err;
2481 	}
2482 	if (spec->cap_mixer) {
2483 		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2484 		if (err < 0)
2485 			return err;
2486 	}
2487 	if (spec->multiout.dig_out_nid) {
2488 		err = snd_hda_create_spdif_out_ctls(codec,
2489 						    spec->multiout.dig_out_nid);
2490 		if (err < 0)
2491 			return err;
2492 		if (!spec->no_analog) {
2493 			err = snd_hda_create_spdif_share_sw(codec,
2494 							    &spec->multiout);
2495 			if (err < 0)
2496 				return err;
2497 			spec->multiout.share_spdif = 1;
2498 		}
2499 	}
2500 	if (spec->dig_in_nid) {
2501 		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2502 		if (err < 0)
2503 			return err;
2504 	}
2505 
2506 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2507 	/* create beep controls if needed */
2508 	if (spec->beep_amp) {
2509 		struct snd_kcontrol_new *knew;
2510 		for (knew = alc_beep_mixer; knew->name; knew++) {
2511 			struct snd_kcontrol *kctl;
2512 			kctl = snd_ctl_new1(knew, codec);
2513 			if (!kctl)
2514 				return -ENOMEM;
2515 			kctl->private_value = spec->beep_amp;
2516 			err = snd_hda_ctl_add(codec, 0, kctl);
2517 			if (err < 0)
2518 				return err;
2519 		}
2520 	}
2521 #endif
2522 
2523 	/* if we have no master control, let's create it */
2524 	if (!spec->no_analog &&
2525 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2526 		unsigned int vmaster_tlv[4];
2527 		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2528 					HDA_OUTPUT, vmaster_tlv);
2529 		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2530 					  vmaster_tlv, alc_slave_vols);
2531 		if (err < 0)
2532 			return err;
2533 	}
2534 	if (!spec->no_analog &&
2535 	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2536 		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2537 					  NULL, alc_slave_sws);
2538 		if (err < 0)
2539 			return err;
2540 	}
2541 
2542 	/* assign Capture Source enums to NID */
2543 	kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2544 	if (!kctl)
2545 		kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2546 	for (i = 0; kctl && i < kctl->count; i++) {
2547 		hda_nid_t *nids = spec->capsrc_nids;
2548 		if (!nids)
2549 			nids = spec->adc_nids;
2550 		err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2551 		if (err < 0)
2552 			return err;
2553 	}
2554 	if (spec->cap_mixer) {
2555 		const char *kname = kctl ? kctl->id.name : NULL;
2556 		for (knew = spec->cap_mixer; knew->name; knew++) {
2557 			if (kname && strcmp(knew->name, kname) == 0)
2558 				continue;
2559 			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2560 			for (i = 0; kctl && i < kctl->count; i++) {
2561 				err = snd_hda_add_nid(codec, kctl, i,
2562 						      spec->adc_nids[i]);
2563 				if (err < 0)
2564 					return err;
2565 			}
2566 		}
2567 	}
2568 
2569 	/* other nid->control mapping */
2570 	for (i = 0; i < spec->num_mixers; i++) {
2571 		for (knew = spec->mixers[i]; knew->name; knew++) {
2572 			if (knew->iface != NID_MAPPING)
2573 				continue;
2574 			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2575 			if (kctl == NULL)
2576 				continue;
2577 			u = knew->subdevice;
2578 			for (j = 0; j < 4; j++, u >>= 8) {
2579 				nid = u & 0x3f;
2580 				if (nid == 0)
2581 					continue;
2582 				switch (u & 0xc0) {
2583 				case SUBDEV_SPEAKER_:
2584 					nid = spec->autocfg.speaker_pins[nid];
2585 					break;
2586 				case SUBDEV_LINE_:
2587 					nid = spec->autocfg.line_out_pins[nid];
2588 					break;
2589 				case SUBDEV_HP_:
2590 					nid = spec->autocfg.hp_pins[nid];
2591 					break;
2592 				default:
2593 					continue;
2594 				}
2595 				err = snd_hda_add_nid(codec, kctl, 0, nid);
2596 				if (err < 0)
2597 					return err;
2598 			}
2599 			u = knew->private_value;
2600 			for (j = 0; j < 4; j++, u >>= 8) {
2601 				nid = u & 0xff;
2602 				if (nid == 0)
2603 					continue;
2604 				err = snd_hda_add_nid(codec, kctl, 0, nid);
2605 				if (err < 0)
2606 					return err;
2607 			}
2608 		}
2609 	}
2610 
2611 	alc_free_kctls(codec); /* no longer needed */
2612 
2613 	return 0;
2614 }
2615 
2616 
2617 /*
2618  * initialize the codec volumes, etc
2619  */
2620 
2621 /*
2622  * generic initialization of ADC, input mixers and output mixers
2623  */
2624 static struct hda_verb alc880_volume_init_verbs[] = {
2625 	/*
2626 	 * Unmute ADC0-2 and set the default input to mic-in
2627 	 */
2628 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2629 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2630 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2631 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2632 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2633 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2634 
2635 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2636 	 * mixer widget
2637 	 * Note: PASD motherboards uses the Line In 2 as the input for front
2638 	 * panel mic (mic 2)
2639 	 */
2640 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2641 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2642 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2643 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2644 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2645 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2646 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2647 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2648 
2649 	/*
2650 	 * Set up output mixers (0x0c - 0x0f)
2651 	 */
2652 	/* set vol=0 to output mixers */
2653 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2654 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2655 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2656 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2657 	/* set up input amps for analog loopback */
2658 	/* Amp Indices: DAC = 0, mixer = 1 */
2659 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2660 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2661 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2662 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2663 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2664 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2665 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2666 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2667 
2668 	{ }
2669 };
2670 
2671 /*
2672  * 3-stack pin configuration:
2673  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2674  */
2675 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2676 	/*
2677 	 * preset connection lists of input pins
2678 	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2679 	 */
2680 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2681 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2682 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2683 
2684 	/*
2685 	 * Set pin mode and muting
2686 	 */
2687 	/* set front pin widgets 0x14 for output */
2688 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2689 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2690 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2691 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2692 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2693 	/* Mic2 (as headphone out) for HP output */
2694 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2695 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2696 	/* Line In pin widget for input */
2697 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2698 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2699 	/* Line2 (as front mic) pin widget for input and vref at 80% */
2700 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2701 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2702 	/* CD pin widget for input */
2703 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2704 
2705 	{ }
2706 };
2707 
2708 /*
2709  * 5-stack pin configuration:
2710  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2711  * line-in/side = 0x1a, f-mic = 0x1b
2712  */
2713 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2714 	/*
2715 	 * preset connection lists of input pins
2716 	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2717 	 */
2718 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2719 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2720 
2721 	/*
2722 	 * Set pin mode and muting
2723 	 */
2724 	/* set pin widgets 0x14-0x17 for output */
2725 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2726 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2727 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2728 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2729 	/* unmute pins for output (no gain on this amp) */
2730 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2731 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2732 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2733 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734 
2735 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
2736 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2737 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2738 	/* Mic2 (as headphone out) for HP output */
2739 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2740 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2741 	/* Line In pin widget for input */
2742 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2743 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2744 	/* Line2 (as front mic) pin widget for input and vref at 80% */
2745 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2746 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2747 	/* CD pin widget for input */
2748 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2749 
2750 	{ }
2751 };
2752 
2753 /*
2754  * W810 pin configuration:
2755  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2756  */
2757 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2758 	/* hphone/speaker input selector: front DAC */
2759 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2760 
2761 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2762 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2763 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2764 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2765 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2766 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2767 
2768 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2769 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2770 
2771 	{ }
2772 };
2773 
2774 /*
2775  * Z71V pin configuration:
2776  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2777  */
2778 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2779 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2780 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2781 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2782 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2783 
2784 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2785 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2786 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2787 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2788 
2789 	{ }
2790 };
2791 
2792 /*
2793  * 6-stack pin configuration:
2794  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2795  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2796  */
2797 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2798 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2799 
2800 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2801 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2802 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2803 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2804 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2805 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2806 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2807 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2808 
2809 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2810 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2811 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2812 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2813 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2814 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2815 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2816 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2817 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2818 
2819 	{ }
2820 };
2821 
2822 /*
2823  * Uniwill pin configuration:
2824  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2825  * line = 0x1a
2826  */
2827 static struct hda_verb alc880_uniwill_init_verbs[] = {
2828 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2829 
2830 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2831 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2832 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2833 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2834 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2835 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2836 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2837 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2838 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2839 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2840 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2841 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2842 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2843 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2844 
2845 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2846 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2847 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2848 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2849 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2850 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2851 	/* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2852 	/* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2853 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2854 
2855 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2856 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2857 
2858 	{ }
2859 };
2860 
2861 /*
2862 * Uniwill P53
2863 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2864  */
2865 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2866 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2867 
2868 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2869 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2870 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2871 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2872 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2873 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2874 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2875 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2876 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2877 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2878 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2879 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2880 
2881 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2882 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2883 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2884 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2885 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2886 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2887 
2888 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2889 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2890 
2891 	{ }
2892 };
2893 
2894 static struct hda_verb alc880_beep_init_verbs[] = {
2895 	{ 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2896 	{ }
2897 };
2898 
2899 /* auto-toggle front mic */
2900 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2901 {
2902  	unsigned int present;
2903 	unsigned char bits;
2904 
2905 	present = snd_hda_jack_detect(codec, 0x18);
2906 	bits = present ? HDA_AMP_MUTE : 0;
2907 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2908 }
2909 
2910 static void alc880_uniwill_setup(struct hda_codec *codec)
2911 {
2912 	struct alc_spec *spec = codec->spec;
2913 
2914 	spec->autocfg.hp_pins[0] = 0x14;
2915 	spec->autocfg.speaker_pins[0] = 0x15;
2916 	spec->autocfg.speaker_pins[0] = 0x16;
2917 }
2918 
2919 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2920 {
2921 	alc_automute_amp(codec);
2922 	alc880_uniwill_mic_automute(codec);
2923 }
2924 
2925 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2926 				       unsigned int res)
2927 {
2928 	/* Looks like the unsol event is incompatible with the standard
2929 	 * definition.  4bit tag is placed at 28 bit!
2930 	 */
2931 	switch (res >> 28) {
2932 	case ALC880_MIC_EVENT:
2933 		alc880_uniwill_mic_automute(codec);
2934 		break;
2935 	default:
2936 		alc_automute_amp_unsol_event(codec, res);
2937 		break;
2938 	}
2939 }
2940 
2941 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2942 {
2943 	struct alc_spec *spec = codec->spec;
2944 
2945 	spec->autocfg.hp_pins[0] = 0x14;
2946 	spec->autocfg.speaker_pins[0] = 0x15;
2947 }
2948 
2949 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2950 {
2951 	unsigned int present;
2952 
2953 	present = snd_hda_codec_read(codec, 0x21, 0,
2954 				     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2955 	present &= HDA_AMP_VOLMASK;
2956 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2957 				 HDA_AMP_VOLMASK, present);
2958 	snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2959 				 HDA_AMP_VOLMASK, present);
2960 }
2961 
2962 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2963 					   unsigned int res)
2964 {
2965 	/* Looks like the unsol event is incompatible with the standard
2966 	 * definition.  4bit tag is placed at 28 bit!
2967 	 */
2968 	if ((res >> 28) == ALC880_DCVOL_EVENT)
2969 		alc880_uniwill_p53_dcvol_automute(codec);
2970 	else
2971 		alc_automute_amp_unsol_event(codec, res);
2972 }
2973 
2974 /*
2975  * F1734 pin configuration:
2976  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2977  */
2978 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2979 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2980 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2981 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2982 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2983 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2984 
2985 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2986 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2987 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2988 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2989 
2990 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2991 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2992 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2993 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2994 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2995 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2996 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2997 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2998 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2999 
3000 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3001 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3002 
3003 	{ }
3004 };
3005 
3006 /*
3007  * ASUS pin configuration:
3008  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3009  */
3010 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3011 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3012 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3013 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3014 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3015 
3016 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3017 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3018 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3019 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3020 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3021 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3022 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3023 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3024 
3025 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3026 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3027 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3028 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3029 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3030 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3031 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3032 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3033 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3034 
3035 	{ }
3036 };
3037 
3038 /* Enable GPIO mask and set output */
3039 #define alc880_gpio1_init_verbs	alc_gpio1_init_verbs
3040 #define alc880_gpio2_init_verbs	alc_gpio2_init_verbs
3041 #define alc880_gpio3_init_verbs	alc_gpio3_init_verbs
3042 
3043 /* Clevo m520g init */
3044 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3045 	/* headphone output */
3046 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3047 	/* line-out */
3048 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3049 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3050 	/* Line-in */
3051 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3052 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3053 	/* CD */
3054 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3055 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3056 	/* Mic1 (rear panel) */
3057 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3058 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3059 	/* Mic2 (front panel) */
3060 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3061 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3062 	/* headphone */
3063 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3064 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3065         /* change to EAPD mode */
3066 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3067 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3068 
3069 	{ }
3070 };
3071 
3072 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3073 	/* change to EAPD mode */
3074 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3075 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3076 
3077 	/* Headphone output */
3078 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3079 	/* Front output*/
3080 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3081 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3082 
3083 	/* Line In pin widget for input */
3084 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3085 	/* CD pin widget for input */
3086 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3087 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3088 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3089 
3090 	/* change to EAPD mode */
3091 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3092 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3093 
3094 	{ }
3095 };
3096 
3097 /*
3098  * LG m1 express dual
3099  *
3100  * Pin assignment:
3101  *   Rear Line-In/Out (blue): 0x14
3102  *   Build-in Mic-In: 0x15
3103  *   Speaker-out: 0x17
3104  *   HP-Out (green): 0x1b
3105  *   Mic-In/Out (red): 0x19
3106  *   SPDIF-Out: 0x1e
3107  */
3108 
3109 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3110 static hda_nid_t alc880_lg_dac_nids[3] = {
3111 	0x05, 0x02, 0x03
3112 };
3113 
3114 /* seems analog CD is not working */
3115 static struct hda_input_mux alc880_lg_capture_source = {
3116 	.num_items = 3,
3117 	.items = {
3118 		{ "Mic", 0x1 },
3119 		{ "Line", 0x5 },
3120 		{ "Internal Mic", 0x6 },
3121 	},
3122 };
3123 
3124 /* 2,4,6 channel modes */
3125 static struct hda_verb alc880_lg_ch2_init[] = {
3126 	/* set line-in and mic-in to input */
3127 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3128 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3129 	{ }
3130 };
3131 
3132 static struct hda_verb alc880_lg_ch4_init[] = {
3133 	/* set line-in to out and mic-in to input */
3134 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3135 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3136 	{ }
3137 };
3138 
3139 static struct hda_verb alc880_lg_ch6_init[] = {
3140 	/* set line-in and mic-in to output */
3141 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3142 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3143 	{ }
3144 };
3145 
3146 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3147 	{ 2, alc880_lg_ch2_init },
3148 	{ 4, alc880_lg_ch4_init },
3149 	{ 6, alc880_lg_ch6_init },
3150 };
3151 
3152 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3153 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3154 	HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3155 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3156 	HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3157 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3158 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3159 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3160 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3161 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3162 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3163 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3164 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3165 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3166 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3167 	{
3168 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3169 		.name = "Channel Mode",
3170 		.info = alc_ch_mode_info,
3171 		.get = alc_ch_mode_get,
3172 		.put = alc_ch_mode_put,
3173 	},
3174 	{ } /* end */
3175 };
3176 
3177 static struct hda_verb alc880_lg_init_verbs[] = {
3178 	/* set capture source to mic-in */
3179 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3180 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3181 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3182 	/* mute all amp mixer inputs */
3183 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3184 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3185 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3186 	/* line-in to input */
3187 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3188 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189 	/* built-in mic */
3190 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3191 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3192 	/* speaker-out */
3193 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3194 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3195 	/* mic-in to input */
3196 	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3197 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3198 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3199 	/* HP-out */
3200 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3201 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3202 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3203 	/* jack sense */
3204 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3205 	{ }
3206 };
3207 
3208 /* toggle speaker-output according to the hp-jack state */
3209 static void alc880_lg_setup(struct hda_codec *codec)
3210 {
3211 	struct alc_spec *spec = codec->spec;
3212 
3213 	spec->autocfg.hp_pins[0] = 0x1b;
3214 	spec->autocfg.speaker_pins[0] = 0x17;
3215 }
3216 
3217 /*
3218  * LG LW20
3219  *
3220  * Pin assignment:
3221  *   Speaker-out: 0x14
3222  *   Mic-In: 0x18
3223  *   Built-in Mic-In: 0x19
3224  *   Line-In: 0x1b
3225  *   HP-Out: 0x1a
3226  *   SPDIF-Out: 0x1e
3227  */
3228 
3229 static struct hda_input_mux alc880_lg_lw_capture_source = {
3230 	.num_items = 3,
3231 	.items = {
3232 		{ "Mic", 0x0 },
3233 		{ "Internal Mic", 0x1 },
3234 		{ "Line In", 0x2 },
3235 	},
3236 };
3237 
3238 #define alc880_lg_lw_modes alc880_threestack_modes
3239 
3240 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3241 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3242 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3243 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3244 	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3245 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3246 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3247 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3248 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3249 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3250 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3251 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3252 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3253 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3254 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3255 	{
3256 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3257 		.name = "Channel Mode",
3258 		.info = alc_ch_mode_info,
3259 		.get = alc_ch_mode_get,
3260 		.put = alc_ch_mode_put,
3261 	},
3262 	{ } /* end */
3263 };
3264 
3265 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3266 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3267 	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3268 	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3269 
3270 	/* set capture source to mic-in */
3271 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3272 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3273 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3274 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3275 	/* speaker-out */
3276 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3277 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3278 	/* HP-out */
3279 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3280 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3281 	/* mic-in to input */
3282 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3283 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3284 	/* built-in mic */
3285 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3286 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3287 	/* jack sense */
3288 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3289 	{ }
3290 };
3291 
3292 /* toggle speaker-output according to the hp-jack state */
3293 static void alc880_lg_lw_setup(struct hda_codec *codec)
3294 {
3295 	struct alc_spec *spec = codec->spec;
3296 
3297 	spec->autocfg.hp_pins[0] = 0x1b;
3298 	spec->autocfg.speaker_pins[0] = 0x14;
3299 }
3300 
3301 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3302 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3303 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3304 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3305 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3306 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3307 	HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3308 	{ } /* end */
3309 };
3310 
3311 static struct hda_input_mux alc880_medion_rim_capture_source = {
3312 	.num_items = 2,
3313 	.items = {
3314 		{ "Mic", 0x0 },
3315 		{ "Internal Mic", 0x1 },
3316 	},
3317 };
3318 
3319 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3320 	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3321 
3322 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3323 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3324 
3325 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3326 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3327 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3328 	/* Mic2 (as headphone out) for HP output */
3329 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3330 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3331 	/* Internal Speaker */
3332 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3333 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3334 
3335 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3336 	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3337 
3338 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3339 	{ }
3340 };
3341 
3342 /* toggle speaker-output according to the hp-jack state */
3343 static void alc880_medion_rim_automute(struct hda_codec *codec)
3344 {
3345 	struct alc_spec *spec = codec->spec;
3346 	alc_automute_amp(codec);
3347 	/* toggle EAPD */
3348 	if (spec->jack_present)
3349 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3350 	else
3351 		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3352 }
3353 
3354 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3355 					  unsigned int res)
3356 {
3357 	/* Looks like the unsol event is incompatible with the standard
3358 	 * definition.  4bit tag is placed at 28 bit!
3359 	 */
3360 	if ((res >> 28) == ALC880_HP_EVENT)
3361 		alc880_medion_rim_automute(codec);
3362 }
3363 
3364 static void alc880_medion_rim_setup(struct hda_codec *codec)
3365 {
3366 	struct alc_spec *spec = codec->spec;
3367 
3368 	spec->autocfg.hp_pins[0] = 0x14;
3369 	spec->autocfg.speaker_pins[0] = 0x1b;
3370 }
3371 
3372 #ifdef CONFIG_SND_HDA_POWER_SAVE
3373 static struct hda_amp_list alc880_loopbacks[] = {
3374 	{ 0x0b, HDA_INPUT, 0 },
3375 	{ 0x0b, HDA_INPUT, 1 },
3376 	{ 0x0b, HDA_INPUT, 2 },
3377 	{ 0x0b, HDA_INPUT, 3 },
3378 	{ 0x0b, HDA_INPUT, 4 },
3379 	{ } /* end */
3380 };
3381 
3382 static struct hda_amp_list alc880_lg_loopbacks[] = {
3383 	{ 0x0b, HDA_INPUT, 1 },
3384 	{ 0x0b, HDA_INPUT, 6 },
3385 	{ 0x0b, HDA_INPUT, 7 },
3386 	{ } /* end */
3387 };
3388 #endif
3389 
3390 /*
3391  * Common callbacks
3392  */
3393 
3394 static int alc_init(struct hda_codec *codec)
3395 {
3396 	struct alc_spec *spec = codec->spec;
3397 	unsigned int i;
3398 
3399 	alc_fix_pll(codec);
3400 	alc_auto_init_amp(codec, spec->init_amp);
3401 
3402 	for (i = 0; i < spec->num_init_verbs; i++)
3403 		snd_hda_sequence_write(codec, spec->init_verbs[i]);
3404 
3405 	if (spec->init_hook)
3406 		spec->init_hook(codec);
3407 
3408 	return 0;
3409 }
3410 
3411 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3412 {
3413 	struct alc_spec *spec = codec->spec;
3414 
3415 	if (spec->unsol_event)
3416 		spec->unsol_event(codec, res);
3417 }
3418 
3419 #ifdef CONFIG_SND_HDA_POWER_SAVE
3420 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3421 {
3422 	struct alc_spec *spec = codec->spec;
3423 	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3424 }
3425 #endif
3426 
3427 /*
3428  * Analog playback callbacks
3429  */
3430 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3431 				    struct hda_codec *codec,
3432 				    struct snd_pcm_substream *substream)
3433 {
3434 	struct alc_spec *spec = codec->spec;
3435 	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3436 					     hinfo);
3437 }
3438 
3439 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3440 				       struct hda_codec *codec,
3441 				       unsigned int stream_tag,
3442 				       unsigned int format,
3443 				       struct snd_pcm_substream *substream)
3444 {
3445 	struct alc_spec *spec = codec->spec;
3446 	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3447 						stream_tag, format, substream);
3448 }
3449 
3450 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3451 				       struct hda_codec *codec,
3452 				       struct snd_pcm_substream *substream)
3453 {
3454 	struct alc_spec *spec = codec->spec;
3455 	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3456 }
3457 
3458 /*
3459  * Digital out
3460  */
3461 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3462 					struct hda_codec *codec,
3463 					struct snd_pcm_substream *substream)
3464 {
3465 	struct alc_spec *spec = codec->spec;
3466 	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3467 }
3468 
3469 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3470 					   struct hda_codec *codec,
3471 					   unsigned int stream_tag,
3472 					   unsigned int format,
3473 					   struct snd_pcm_substream *substream)
3474 {
3475 	struct alc_spec *spec = codec->spec;
3476 	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3477 					     stream_tag, format, substream);
3478 }
3479 
3480 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3481 					   struct hda_codec *codec,
3482 					   struct snd_pcm_substream *substream)
3483 {
3484 	struct alc_spec *spec = codec->spec;
3485 	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3486 }
3487 
3488 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3489 					 struct hda_codec *codec,
3490 					 struct snd_pcm_substream *substream)
3491 {
3492 	struct alc_spec *spec = codec->spec;
3493 	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3494 }
3495 
3496 /*
3497  * Analog capture
3498  */
3499 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3500 				      struct hda_codec *codec,
3501 				      unsigned int stream_tag,
3502 				      unsigned int format,
3503 				      struct snd_pcm_substream *substream)
3504 {
3505 	struct alc_spec *spec = codec->spec;
3506 
3507 	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3508 				   stream_tag, 0, format);
3509 	return 0;
3510 }
3511 
3512 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3513 				      struct hda_codec *codec,
3514 				      struct snd_pcm_substream *substream)
3515 {
3516 	struct alc_spec *spec = codec->spec;
3517 
3518 	snd_hda_codec_cleanup_stream(codec,
3519 				     spec->adc_nids[substream->number + 1]);
3520 	return 0;
3521 }
3522 
3523 
3524 /*
3525  */
3526 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3527 	.substreams = 1,
3528 	.channels_min = 2,
3529 	.channels_max = 8,
3530 	/* NID is set in alc_build_pcms */
3531 	.ops = {
3532 		.open = alc880_playback_pcm_open,
3533 		.prepare = alc880_playback_pcm_prepare,
3534 		.cleanup = alc880_playback_pcm_cleanup
3535 	},
3536 };
3537 
3538 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3539 	.substreams = 1,
3540 	.channels_min = 2,
3541 	.channels_max = 2,
3542 	/* NID is set in alc_build_pcms */
3543 };
3544 
3545 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3546 	.substreams = 1,
3547 	.channels_min = 2,
3548 	.channels_max = 2,
3549 	/* NID is set in alc_build_pcms */
3550 };
3551 
3552 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3553 	.substreams = 2, /* can be overridden */
3554 	.channels_min = 2,
3555 	.channels_max = 2,
3556 	/* NID is set in alc_build_pcms */
3557 	.ops = {
3558 		.prepare = alc880_alt_capture_pcm_prepare,
3559 		.cleanup = alc880_alt_capture_pcm_cleanup
3560 	},
3561 };
3562 
3563 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3564 	.substreams = 1,
3565 	.channels_min = 2,
3566 	.channels_max = 2,
3567 	/* NID is set in alc_build_pcms */
3568 	.ops = {
3569 		.open = alc880_dig_playback_pcm_open,
3570 		.close = alc880_dig_playback_pcm_close,
3571 		.prepare = alc880_dig_playback_pcm_prepare,
3572 		.cleanup = alc880_dig_playback_pcm_cleanup
3573 	},
3574 };
3575 
3576 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3577 	.substreams = 1,
3578 	.channels_min = 2,
3579 	.channels_max = 2,
3580 	/* NID is set in alc_build_pcms */
3581 };
3582 
3583 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3584 static struct hda_pcm_stream alc_pcm_null_stream = {
3585 	.substreams = 0,
3586 	.channels_min = 0,
3587 	.channels_max = 0,
3588 };
3589 
3590 static int alc_build_pcms(struct hda_codec *codec)
3591 {
3592 	struct alc_spec *spec = codec->spec;
3593 	struct hda_pcm *info = spec->pcm_rec;
3594 	int i;
3595 
3596 	codec->num_pcms = 1;
3597 	codec->pcm_info = info;
3598 
3599 	if (spec->no_analog)
3600 		goto skip_analog;
3601 
3602 	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3603 		 "%s Analog", codec->chip_name);
3604 	info->name = spec->stream_name_analog;
3605 
3606 	if (spec->stream_analog_playback) {
3607 		if (snd_BUG_ON(!spec->multiout.dac_nids))
3608 			return -EINVAL;
3609 		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3610 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3611 	}
3612 	if (spec->stream_analog_capture) {
3613 		if (snd_BUG_ON(!spec->adc_nids))
3614 			return -EINVAL;
3615 		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3616 		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3617 	}
3618 
3619 	if (spec->channel_mode) {
3620 		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3621 		for (i = 0; i < spec->num_channel_mode; i++) {
3622 			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3623 				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3624 			}
3625 		}
3626 	}
3627 
3628  skip_analog:
3629 	/* SPDIF for stream index #1 */
3630 	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3631 		snprintf(spec->stream_name_digital,
3632 			 sizeof(spec->stream_name_digital),
3633 			 "%s Digital", codec->chip_name);
3634 		codec->num_pcms = 2;
3635 	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3636 		info = spec->pcm_rec + 1;
3637 		info->name = spec->stream_name_digital;
3638 		if (spec->dig_out_type)
3639 			info->pcm_type = spec->dig_out_type;
3640 		else
3641 			info->pcm_type = HDA_PCM_TYPE_SPDIF;
3642 		if (spec->multiout.dig_out_nid &&
3643 		    spec->stream_digital_playback) {
3644 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3645 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3646 		}
3647 		if (spec->dig_in_nid &&
3648 		    spec->stream_digital_capture) {
3649 			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3650 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3651 		}
3652 		/* FIXME: do we need this for all Realtek codec models? */
3653 		codec->spdif_status_reset = 1;
3654 	}
3655 
3656 	if (spec->no_analog)
3657 		return 0;
3658 
3659 	/* If the use of more than one ADC is requested for the current
3660 	 * model, configure a second analog capture-only PCM.
3661 	 */
3662 	/* Additional Analaog capture for index #2 */
3663 	if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3664 	    (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3665 		codec->num_pcms = 3;
3666 		info = spec->pcm_rec + 2;
3667 		info->name = spec->stream_name_analog;
3668 		if (spec->alt_dac_nid) {
3669 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3670 				*spec->stream_analog_alt_playback;
3671 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3672 				spec->alt_dac_nid;
3673 		} else {
3674 			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3675 				alc_pcm_null_stream;
3676 			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3677 		}
3678 		if (spec->num_adc_nids > 1) {
3679 			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3680 				*spec->stream_analog_alt_capture;
3681 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3682 				spec->adc_nids[1];
3683 			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3684 				spec->num_adc_nids - 1;
3685 		} else {
3686 			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3687 				alc_pcm_null_stream;
3688 			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3689 		}
3690 	}
3691 
3692 	return 0;
3693 }
3694 
3695 static inline void alc_shutup(struct hda_codec *codec)
3696 {
3697 	snd_hda_shutup_pins(codec);
3698 }
3699 
3700 static void alc_free_kctls(struct hda_codec *codec)
3701 {
3702 	struct alc_spec *spec = codec->spec;
3703 
3704 	if (spec->kctls.list) {
3705 		struct snd_kcontrol_new *kctl = spec->kctls.list;
3706 		int i;
3707 		for (i = 0; i < spec->kctls.used; i++)
3708 			kfree(kctl[i].name);
3709 	}
3710 	snd_array_free(&spec->kctls);
3711 }
3712 
3713 static void alc_free(struct hda_codec *codec)
3714 {
3715 	struct alc_spec *spec = codec->spec;
3716 
3717 	if (!spec)
3718 		return;
3719 
3720 	alc_shutup(codec);
3721 	alc_free_kctls(codec);
3722 	kfree(spec);
3723 	snd_hda_detach_beep_device(codec);
3724 }
3725 
3726 #ifdef CONFIG_SND_HDA_POWER_SAVE
3727 static void alc_power_eapd(struct hda_codec *codec)
3728 {
3729 	/* We currently only handle front, HP */
3730 	switch (codec->vendor_id) {
3731 	case 0x10ec0260:
3732 		set_eapd(codec, 0x0f, 0);
3733 		set_eapd(codec, 0x10, 0);
3734 		break;
3735 	case 0x10ec0262:
3736 	case 0x10ec0267:
3737 	case 0x10ec0268:
3738 	case 0x10ec0269:
3739 	case 0x10ec0270:
3740 	case 0x10ec0272:
3741 	case 0x10ec0660:
3742 	case 0x10ec0662:
3743 	case 0x10ec0663:
3744 	case 0x10ec0862:
3745 	case 0x10ec0889:
3746 		set_eapd(codec, 0x14, 0);
3747 		set_eapd(codec, 0x15, 0);
3748 		break;
3749 	}
3750 }
3751 
3752 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3753 {
3754 	struct alc_spec *spec = codec->spec;
3755 	alc_shutup(codec);
3756 	if (spec && spec->power_hook)
3757 		spec->power_hook(codec);
3758 	return 0;
3759 }
3760 #endif
3761 
3762 #ifdef SND_HDA_NEEDS_RESUME
3763 static int alc_resume(struct hda_codec *codec)
3764 {
3765 	codec->patch_ops.init(codec);
3766 	snd_hda_codec_resume_amp(codec);
3767 	snd_hda_codec_resume_cache(codec);
3768 	return 0;
3769 }
3770 #endif
3771 
3772 /*
3773  */
3774 static struct hda_codec_ops alc_patch_ops = {
3775 	.build_controls = alc_build_controls,
3776 	.build_pcms = alc_build_pcms,
3777 	.init = alc_init,
3778 	.free = alc_free,
3779 	.unsol_event = alc_unsol_event,
3780 #ifdef SND_HDA_NEEDS_RESUME
3781 	.resume = alc_resume,
3782 #endif
3783 #ifdef CONFIG_SND_HDA_POWER_SAVE
3784 	.suspend = alc_suspend,
3785 	.check_power_status = alc_check_power_status,
3786 #endif
3787 	.reboot_notify = alc_shutup,
3788 };
3789 
3790 
3791 /*
3792  * Test configuration for debugging
3793  *
3794  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3795  * enum controls.
3796  */
3797 #ifdef CONFIG_SND_DEBUG
3798 static hda_nid_t alc880_test_dac_nids[4] = {
3799 	0x02, 0x03, 0x04, 0x05
3800 };
3801 
3802 static struct hda_input_mux alc880_test_capture_source = {
3803 	.num_items = 7,
3804 	.items = {
3805 		{ "In-1", 0x0 },
3806 		{ "In-2", 0x1 },
3807 		{ "In-3", 0x2 },
3808 		{ "In-4", 0x3 },
3809 		{ "CD", 0x4 },
3810 		{ "Front", 0x5 },
3811 		{ "Surround", 0x6 },
3812 	},
3813 };
3814 
3815 static struct hda_channel_mode alc880_test_modes[4] = {
3816 	{ 2, NULL },
3817 	{ 4, NULL },
3818 	{ 6, NULL },
3819 	{ 8, NULL },
3820 };
3821 
3822 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3823 				 struct snd_ctl_elem_info *uinfo)
3824 {
3825 	static char *texts[] = {
3826 		"N/A", "Line Out", "HP Out",
3827 		"In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3828 	};
3829 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3830 	uinfo->count = 1;
3831 	uinfo->value.enumerated.items = 8;
3832 	if (uinfo->value.enumerated.item >= 8)
3833 		uinfo->value.enumerated.item = 7;
3834 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3835 	return 0;
3836 }
3837 
3838 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3839 				struct snd_ctl_elem_value *ucontrol)
3840 {
3841 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3842 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3843 	unsigned int pin_ctl, item = 0;
3844 
3845 	pin_ctl = snd_hda_codec_read(codec, nid, 0,
3846 				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3847 	if (pin_ctl & AC_PINCTL_OUT_EN) {
3848 		if (pin_ctl & AC_PINCTL_HP_EN)
3849 			item = 2;
3850 		else
3851 			item = 1;
3852 	} else if (pin_ctl & AC_PINCTL_IN_EN) {
3853 		switch (pin_ctl & AC_PINCTL_VREFEN) {
3854 		case AC_PINCTL_VREF_HIZ: item = 3; break;
3855 		case AC_PINCTL_VREF_50:  item = 4; break;
3856 		case AC_PINCTL_VREF_GRD: item = 5; break;
3857 		case AC_PINCTL_VREF_80:  item = 6; break;
3858 		case AC_PINCTL_VREF_100: item = 7; break;
3859 		}
3860 	}
3861 	ucontrol->value.enumerated.item[0] = item;
3862 	return 0;
3863 }
3864 
3865 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3866 				struct snd_ctl_elem_value *ucontrol)
3867 {
3868 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3869 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3870 	static unsigned int ctls[] = {
3871 		0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3872 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3873 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3874 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3875 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3876 		AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3877 	};
3878 	unsigned int old_ctl, new_ctl;
3879 
3880 	old_ctl = snd_hda_codec_read(codec, nid, 0,
3881 				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3882 	new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3883 	if (old_ctl != new_ctl) {
3884 		int val;
3885 		snd_hda_codec_write_cache(codec, nid, 0,
3886 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
3887 					  new_ctl);
3888 		val = ucontrol->value.enumerated.item[0] >= 3 ?
3889 			HDA_AMP_MUTE : 0;
3890 		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3891 					 HDA_AMP_MUTE, val);
3892 		return 1;
3893 	}
3894 	return 0;
3895 }
3896 
3897 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3898 				 struct snd_ctl_elem_info *uinfo)
3899 {
3900 	static char *texts[] = {
3901 		"Front", "Surround", "CLFE", "Side"
3902 	};
3903 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3904 	uinfo->count = 1;
3905 	uinfo->value.enumerated.items = 4;
3906 	if (uinfo->value.enumerated.item >= 4)
3907 		uinfo->value.enumerated.item = 3;
3908 	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3909 	return 0;
3910 }
3911 
3912 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3913 				struct snd_ctl_elem_value *ucontrol)
3914 {
3915 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3916 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3917 	unsigned int sel;
3918 
3919 	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3920 	ucontrol->value.enumerated.item[0] = sel & 3;
3921 	return 0;
3922 }
3923 
3924 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3925 				struct snd_ctl_elem_value *ucontrol)
3926 {
3927 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3928 	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3929 	unsigned int sel;
3930 
3931 	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3932 	if (ucontrol->value.enumerated.item[0] != sel) {
3933 		sel = ucontrol->value.enumerated.item[0] & 3;
3934 		snd_hda_codec_write_cache(codec, nid, 0,
3935 					  AC_VERB_SET_CONNECT_SEL, sel);
3936 		return 1;
3937 	}
3938 	return 0;
3939 }
3940 
3941 #define PIN_CTL_TEST(xname,nid) {			\
3942 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
3943 			.name = xname,		       \
3944 			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3945 			.info = alc_test_pin_ctl_info, \
3946 			.get = alc_test_pin_ctl_get,   \
3947 			.put = alc_test_pin_ctl_put,   \
3948 			.private_value = nid	       \
3949 			}
3950 
3951 #define PIN_SRC_TEST(xname,nid) {			\
3952 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
3953 			.name = xname,		       \
3954 			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3955 			.info = alc_test_pin_src_info, \
3956 			.get = alc_test_pin_src_get,   \
3957 			.put = alc_test_pin_src_put,   \
3958 			.private_value = nid	       \
3959 			}
3960 
3961 static struct snd_kcontrol_new alc880_test_mixer[] = {
3962 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3963 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3964 	HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3965 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3966 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3967 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3968 	HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3969 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3970 	PIN_CTL_TEST("Front Pin Mode", 0x14),
3971 	PIN_CTL_TEST("Surround Pin Mode", 0x15),
3972 	PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3973 	PIN_CTL_TEST("Side Pin Mode", 0x17),
3974 	PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3975 	PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3976 	PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3977 	PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3978 	PIN_SRC_TEST("In-1 Pin Source", 0x18),
3979 	PIN_SRC_TEST("In-2 Pin Source", 0x19),
3980 	PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3981 	PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3982 	HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3983 	HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3984 	HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3985 	HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3986 	HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3987 	HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3988 	HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3989 	HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3990 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3991 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3992 	{
3993 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3994 		.name = "Channel Mode",
3995 		.info = alc_ch_mode_info,
3996 		.get = alc_ch_mode_get,
3997 		.put = alc_ch_mode_put,
3998 	},
3999 	{ } /* end */
4000 };
4001 
4002 static struct hda_verb alc880_test_init_verbs[] = {
4003 	/* Unmute inputs of 0x0c - 0x0f */
4004 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4005 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4006 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4007 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4008 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4009 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4010 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4011 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4012 	/* Vol output for 0x0c-0x0f */
4013 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4014 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4015 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4016 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4017 	/* Set output pins 0x14-0x17 */
4018 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4019 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4020 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4021 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4022 	/* Unmute output pins 0x14-0x17 */
4023 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4024 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4025 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4026 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4027 	/* Set input pins 0x18-0x1c */
4028 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4029 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4030 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4031 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4032 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4033 	/* Mute input pins 0x18-0x1b */
4034 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4035 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4036 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4037 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4038 	/* ADC set up */
4039 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4040 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4041 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4042 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4043 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4044 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4045 	/* Analog input/passthru */
4046 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4047 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4048 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4049 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4050 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4051 	{ }
4052 };
4053 #endif
4054 
4055 /*
4056  */
4057 
4058 static const char *alc880_models[ALC880_MODEL_LAST] = {
4059 	[ALC880_3ST]		= "3stack",
4060 	[ALC880_TCL_S700]	= "tcl",
4061 	[ALC880_3ST_DIG]	= "3stack-digout",
4062 	[ALC880_CLEVO]		= "clevo",
4063 	[ALC880_5ST]		= "5stack",
4064 	[ALC880_5ST_DIG]	= "5stack-digout",
4065 	[ALC880_W810]		= "w810",
4066 	[ALC880_Z71V]		= "z71v",
4067 	[ALC880_6ST]		= "6stack",
4068 	[ALC880_6ST_DIG]	= "6stack-digout",
4069 	[ALC880_ASUS]		= "asus",
4070 	[ALC880_ASUS_W1V]	= "asus-w1v",
4071 	[ALC880_ASUS_DIG]	= "asus-dig",
4072 	[ALC880_ASUS_DIG2]	= "asus-dig2",
4073 	[ALC880_UNIWILL_DIG]	= "uniwill",
4074 	[ALC880_UNIWILL_P53]	= "uniwill-p53",
4075 	[ALC880_FUJITSU]	= "fujitsu",
4076 	[ALC880_F1734]		= "F1734",
4077 	[ALC880_LG]		= "lg",
4078 	[ALC880_LG_LW]		= "lg-lw",
4079 	[ALC880_MEDION_RIM]	= "medion",
4080 #ifdef CONFIG_SND_DEBUG
4081 	[ALC880_TEST]		= "test",
4082 #endif
4083 	[ALC880_AUTO]		= "auto",
4084 };
4085 
4086 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4087 	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4088 	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4089 	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4090 	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4091 	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4092 	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4093 	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4094 	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4095 	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4096 	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4097 	SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4098 	SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4099 	SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4100 	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4101 	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4102 	SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4103 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4104 	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4105 	/* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4106 	SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4107 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4108 	SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4109 	SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4110 	SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4111 	SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4112 	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4113 	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4114 	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4115 	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4116 	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4117 	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4118 	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4119 	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4120 	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4121 	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4122 	SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4123 	SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4124 	SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4125 	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4126 	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4127 	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4128 	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4129 	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4130 	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4131 	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4132 	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4133 	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4134 	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4135 	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4136 	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4137 	SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4138 	SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4139 	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4140 	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4141 	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4142 	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4143 	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4144 	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4145 	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4146 	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4147 	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4148 	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4149 	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4150 	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4151 	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4152 	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4153 	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4154 	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4155 	/* default Intel */
4156 	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4157 	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4158 	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4159 	{}
4160 };
4161 
4162 /*
4163  * ALC880 codec presets
4164  */
4165 static struct alc_config_preset alc880_presets[] = {
4166 	[ALC880_3ST] = {
4167 		.mixers = { alc880_three_stack_mixer },
4168 		.init_verbs = { alc880_volume_init_verbs,
4169 				alc880_pin_3stack_init_verbs },
4170 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4171 		.dac_nids = alc880_dac_nids,
4172 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4173 		.channel_mode = alc880_threestack_modes,
4174 		.need_dac_fix = 1,
4175 		.input_mux = &alc880_capture_source,
4176 	},
4177 	[ALC880_3ST_DIG] = {
4178 		.mixers = { alc880_three_stack_mixer },
4179 		.init_verbs = { alc880_volume_init_verbs,
4180 				alc880_pin_3stack_init_verbs },
4181 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4182 		.dac_nids = alc880_dac_nids,
4183 		.dig_out_nid = ALC880_DIGOUT_NID,
4184 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4185 		.channel_mode = alc880_threestack_modes,
4186 		.need_dac_fix = 1,
4187 		.input_mux = &alc880_capture_source,
4188 	},
4189 	[ALC880_TCL_S700] = {
4190 		.mixers = { alc880_tcl_s700_mixer },
4191 		.init_verbs = { alc880_volume_init_verbs,
4192 				alc880_pin_tcl_S700_init_verbs,
4193 				alc880_gpio2_init_verbs },
4194 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4195 		.dac_nids = alc880_dac_nids,
4196 		.adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4197 		.num_adc_nids = 1, /* single ADC */
4198 		.hp_nid = 0x03,
4199 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4200 		.channel_mode = alc880_2_jack_modes,
4201 		.input_mux = &alc880_capture_source,
4202 	},
4203 	[ALC880_5ST] = {
4204 		.mixers = { alc880_three_stack_mixer,
4205 			    alc880_five_stack_mixer},
4206 		.init_verbs = { alc880_volume_init_verbs,
4207 				alc880_pin_5stack_init_verbs },
4208 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4209 		.dac_nids = alc880_dac_nids,
4210 		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4211 		.channel_mode = alc880_fivestack_modes,
4212 		.input_mux = &alc880_capture_source,
4213 	},
4214 	[ALC880_5ST_DIG] = {
4215 		.mixers = { alc880_three_stack_mixer,
4216 			    alc880_five_stack_mixer },
4217 		.init_verbs = { alc880_volume_init_verbs,
4218 				alc880_pin_5stack_init_verbs },
4219 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4220 		.dac_nids = alc880_dac_nids,
4221 		.dig_out_nid = ALC880_DIGOUT_NID,
4222 		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4223 		.channel_mode = alc880_fivestack_modes,
4224 		.input_mux = &alc880_capture_source,
4225 	},
4226 	[ALC880_6ST] = {
4227 		.mixers = { alc880_six_stack_mixer },
4228 		.init_verbs = { alc880_volume_init_verbs,
4229 				alc880_pin_6stack_init_verbs },
4230 		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4231 		.dac_nids = alc880_6st_dac_nids,
4232 		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4233 		.channel_mode = alc880_sixstack_modes,
4234 		.input_mux = &alc880_6stack_capture_source,
4235 	},
4236 	[ALC880_6ST_DIG] = {
4237 		.mixers = { alc880_six_stack_mixer },
4238 		.init_verbs = { alc880_volume_init_verbs,
4239 				alc880_pin_6stack_init_verbs },
4240 		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4241 		.dac_nids = alc880_6st_dac_nids,
4242 		.dig_out_nid = ALC880_DIGOUT_NID,
4243 		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4244 		.channel_mode = alc880_sixstack_modes,
4245 		.input_mux = &alc880_6stack_capture_source,
4246 	},
4247 	[ALC880_W810] = {
4248 		.mixers = { alc880_w810_base_mixer },
4249 		.init_verbs = { alc880_volume_init_verbs,
4250 				alc880_pin_w810_init_verbs,
4251 				alc880_gpio2_init_verbs },
4252 		.num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4253 		.dac_nids = alc880_w810_dac_nids,
4254 		.dig_out_nid = ALC880_DIGOUT_NID,
4255 		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4256 		.channel_mode = alc880_w810_modes,
4257 		.input_mux = &alc880_capture_source,
4258 	},
4259 	[ALC880_Z71V] = {
4260 		.mixers = { alc880_z71v_mixer },
4261 		.init_verbs = { alc880_volume_init_verbs,
4262 				alc880_pin_z71v_init_verbs },
4263 		.num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4264 		.dac_nids = alc880_z71v_dac_nids,
4265 		.dig_out_nid = ALC880_DIGOUT_NID,
4266 		.hp_nid = 0x03,
4267 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4268 		.channel_mode = alc880_2_jack_modes,
4269 		.input_mux = &alc880_capture_source,
4270 	},
4271 	[ALC880_F1734] = {
4272 		.mixers = { alc880_f1734_mixer },
4273 		.init_verbs = { alc880_volume_init_verbs,
4274 				alc880_pin_f1734_init_verbs },
4275 		.num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4276 		.dac_nids = alc880_f1734_dac_nids,
4277 		.hp_nid = 0x02,
4278 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4279 		.channel_mode = alc880_2_jack_modes,
4280 		.input_mux = &alc880_f1734_capture_source,
4281 		.unsol_event = alc880_uniwill_p53_unsol_event,
4282 		.setup = alc880_uniwill_p53_setup,
4283 		.init_hook = alc_automute_amp,
4284 	},
4285 	[ALC880_ASUS] = {
4286 		.mixers = { alc880_asus_mixer },
4287 		.init_verbs = { alc880_volume_init_verbs,
4288 				alc880_pin_asus_init_verbs,
4289 				alc880_gpio1_init_verbs },
4290 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4291 		.dac_nids = alc880_asus_dac_nids,
4292 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4293 		.channel_mode = alc880_asus_modes,
4294 		.need_dac_fix = 1,
4295 		.input_mux = &alc880_capture_source,
4296 	},
4297 	[ALC880_ASUS_DIG] = {
4298 		.mixers = { alc880_asus_mixer },
4299 		.init_verbs = { alc880_volume_init_verbs,
4300 				alc880_pin_asus_init_verbs,
4301 				alc880_gpio1_init_verbs },
4302 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4303 		.dac_nids = alc880_asus_dac_nids,
4304 		.dig_out_nid = ALC880_DIGOUT_NID,
4305 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4306 		.channel_mode = alc880_asus_modes,
4307 		.need_dac_fix = 1,
4308 		.input_mux = &alc880_capture_source,
4309 	},
4310 	[ALC880_ASUS_DIG2] = {
4311 		.mixers = { alc880_asus_mixer },
4312 		.init_verbs = { alc880_volume_init_verbs,
4313 				alc880_pin_asus_init_verbs,
4314 				alc880_gpio2_init_verbs }, /* use GPIO2 */
4315 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4316 		.dac_nids = alc880_asus_dac_nids,
4317 		.dig_out_nid = ALC880_DIGOUT_NID,
4318 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4319 		.channel_mode = alc880_asus_modes,
4320 		.need_dac_fix = 1,
4321 		.input_mux = &alc880_capture_source,
4322 	},
4323 	[ALC880_ASUS_W1V] = {
4324 		.mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4325 		.init_verbs = { alc880_volume_init_verbs,
4326 				alc880_pin_asus_init_verbs,
4327 				alc880_gpio1_init_verbs },
4328 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4329 		.dac_nids = alc880_asus_dac_nids,
4330 		.dig_out_nid = ALC880_DIGOUT_NID,
4331 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4332 		.channel_mode = alc880_asus_modes,
4333 		.need_dac_fix = 1,
4334 		.input_mux = &alc880_capture_source,
4335 	},
4336 	[ALC880_UNIWILL_DIG] = {
4337 		.mixers = { alc880_asus_mixer },
4338 		.init_verbs = { alc880_volume_init_verbs,
4339 				alc880_pin_asus_init_verbs },
4340 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4341 		.dac_nids = alc880_asus_dac_nids,
4342 		.dig_out_nid = ALC880_DIGOUT_NID,
4343 		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4344 		.channel_mode = alc880_asus_modes,
4345 		.need_dac_fix = 1,
4346 		.input_mux = &alc880_capture_source,
4347 	},
4348 	[ALC880_UNIWILL] = {
4349 		.mixers = { alc880_uniwill_mixer },
4350 		.init_verbs = { alc880_volume_init_verbs,
4351 				alc880_uniwill_init_verbs },
4352 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4353 		.dac_nids = alc880_asus_dac_nids,
4354 		.dig_out_nid = ALC880_DIGOUT_NID,
4355 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4356 		.channel_mode = alc880_threestack_modes,
4357 		.need_dac_fix = 1,
4358 		.input_mux = &alc880_capture_source,
4359 		.unsol_event = alc880_uniwill_unsol_event,
4360 		.setup = alc880_uniwill_setup,
4361 		.init_hook = alc880_uniwill_init_hook,
4362 	},
4363 	[ALC880_UNIWILL_P53] = {
4364 		.mixers = { alc880_uniwill_p53_mixer },
4365 		.init_verbs = { alc880_volume_init_verbs,
4366 				alc880_uniwill_p53_init_verbs },
4367 		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4368 		.dac_nids = alc880_asus_dac_nids,
4369 		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4370 		.channel_mode = alc880_threestack_modes,
4371 		.input_mux = &alc880_capture_source,
4372 		.unsol_event = alc880_uniwill_p53_unsol_event,
4373 		.setup = alc880_uniwill_p53_setup,
4374 		.init_hook = alc_automute_amp,
4375 	},
4376 	[ALC880_FUJITSU] = {
4377 		.mixers = { alc880_fujitsu_mixer },
4378 		.init_verbs = { alc880_volume_init_verbs,
4379 				alc880_uniwill_p53_init_verbs,
4380 	       			alc880_beep_init_verbs },
4381 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4382 		.dac_nids = alc880_dac_nids,
4383 		.dig_out_nid = ALC880_DIGOUT_NID,
4384 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4385 		.channel_mode = alc880_2_jack_modes,
4386 		.input_mux = &alc880_capture_source,
4387 		.unsol_event = alc880_uniwill_p53_unsol_event,
4388 		.setup = alc880_uniwill_p53_setup,
4389 		.init_hook = alc_automute_amp,
4390 	},
4391 	[ALC880_CLEVO] = {
4392 		.mixers = { alc880_three_stack_mixer },
4393 		.init_verbs = { alc880_volume_init_verbs,
4394 				alc880_pin_clevo_init_verbs },
4395 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4396 		.dac_nids = alc880_dac_nids,
4397 		.hp_nid = 0x03,
4398 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4399 		.channel_mode = alc880_threestack_modes,
4400 		.need_dac_fix = 1,
4401 		.input_mux = &alc880_capture_source,
4402 	},
4403 	[ALC880_LG] = {
4404 		.mixers = { alc880_lg_mixer },
4405 		.init_verbs = { alc880_volume_init_verbs,
4406 				alc880_lg_init_verbs },
4407 		.num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4408 		.dac_nids = alc880_lg_dac_nids,
4409 		.dig_out_nid = ALC880_DIGOUT_NID,
4410 		.num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4411 		.channel_mode = alc880_lg_ch_modes,
4412 		.need_dac_fix = 1,
4413 		.input_mux = &alc880_lg_capture_source,
4414 		.unsol_event = alc_automute_amp_unsol_event,
4415 		.setup = alc880_lg_setup,
4416 		.init_hook = alc_automute_amp,
4417 #ifdef CONFIG_SND_HDA_POWER_SAVE
4418 		.loopbacks = alc880_lg_loopbacks,
4419 #endif
4420 	},
4421 	[ALC880_LG_LW] = {
4422 		.mixers = { alc880_lg_lw_mixer },
4423 		.init_verbs = { alc880_volume_init_verbs,
4424 				alc880_lg_lw_init_verbs },
4425 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4426 		.dac_nids = alc880_dac_nids,
4427 		.dig_out_nid = ALC880_DIGOUT_NID,
4428 		.num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4429 		.channel_mode = alc880_lg_lw_modes,
4430 		.input_mux = &alc880_lg_lw_capture_source,
4431 		.unsol_event = alc_automute_amp_unsol_event,
4432 		.setup = alc880_lg_lw_setup,
4433 		.init_hook = alc_automute_amp,
4434 	},
4435 	[ALC880_MEDION_RIM] = {
4436 		.mixers = { alc880_medion_rim_mixer },
4437 		.init_verbs = { alc880_volume_init_verbs,
4438 				alc880_medion_rim_init_verbs,
4439 				alc_gpio2_init_verbs },
4440 		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4441 		.dac_nids = alc880_dac_nids,
4442 		.dig_out_nid = ALC880_DIGOUT_NID,
4443 		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4444 		.channel_mode = alc880_2_jack_modes,
4445 		.input_mux = &alc880_medion_rim_capture_source,
4446 		.unsol_event = alc880_medion_rim_unsol_event,
4447 		.setup = alc880_medion_rim_setup,
4448 		.init_hook = alc880_medion_rim_automute,
4449 	},
4450 #ifdef CONFIG_SND_DEBUG
4451 	[ALC880_TEST] = {
4452 		.mixers = { alc880_test_mixer },
4453 		.init_verbs = { alc880_test_init_verbs },
4454 		.num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4455 		.dac_nids = alc880_test_dac_nids,
4456 		.dig_out_nid = ALC880_DIGOUT_NID,
4457 		.num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4458 		.channel_mode = alc880_test_modes,
4459 		.input_mux = &alc880_test_capture_source,
4460 	},
4461 #endif
4462 };
4463 
4464 /*
4465  * Automatic parse of I/O pins from the BIOS configuration
4466  */
4467 
4468 enum {
4469 	ALC_CTL_WIDGET_VOL,
4470 	ALC_CTL_WIDGET_MUTE,
4471 	ALC_CTL_BIND_MUTE,
4472 };
4473 static struct snd_kcontrol_new alc880_control_templates[] = {
4474 	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4475 	HDA_CODEC_MUTE(NULL, 0, 0, 0),
4476 	HDA_BIND_MUTE(NULL, 0, 0, 0),
4477 };
4478 
4479 /* add dynamic controls */
4480 static int add_control(struct alc_spec *spec, int type, const char *name,
4481 		       unsigned long val)
4482 {
4483 	struct snd_kcontrol_new *knew;
4484 
4485 	snd_array_init(&spec->kctls, sizeof(*knew), 32);
4486 	knew = snd_array_new(&spec->kctls);
4487 	if (!knew)
4488 		return -ENOMEM;
4489 	*knew = alc880_control_templates[type];
4490 	knew->name = kstrdup(name, GFP_KERNEL);
4491 	if (!knew->name)
4492 		return -ENOMEM;
4493 	if (get_amp_nid_(val))
4494 		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4495 	knew->private_value = val;
4496 	return 0;
4497 }
4498 
4499 static int add_control_with_pfx(struct alc_spec *spec, int type,
4500 				const char *pfx, const char *dir,
4501 				const char *sfx, unsigned long val)
4502 {
4503 	char name[32];
4504 	snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4505 	return add_control(spec, type, name, val);
4506 }
4507 
4508 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4509 	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4510 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4511 	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4512 
4513 #define alc880_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
4514 #define alc880_fixed_pin_idx(nid)	((nid) - 0x14)
4515 #define alc880_is_multi_pin(nid)	((nid) >= 0x18)
4516 #define alc880_multi_pin_idx(nid)	((nid) - 0x18)
4517 #define alc880_idx_to_dac(nid)		((nid) + 0x02)
4518 #define alc880_dac_to_idx(nid)		((nid) - 0x02)
4519 #define alc880_idx_to_mixer(nid)	((nid) + 0x0c)
4520 #define alc880_idx_to_selector(nid)	((nid) + 0x10)
4521 #define ALC880_PIN_CD_NID		0x1c
4522 
4523 /* fill in the dac_nids table from the parsed pin configuration */
4524 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4525 				     const struct auto_pin_cfg *cfg)
4526 {
4527 	hda_nid_t nid;
4528 	int assigned[4];
4529 	int i, j;
4530 
4531 	memset(assigned, 0, sizeof(assigned));
4532 	spec->multiout.dac_nids = spec->private_dac_nids;
4533 
4534 	/* check the pins hardwired to audio widget */
4535 	for (i = 0; i < cfg->line_outs; i++) {
4536 		nid = cfg->line_out_pins[i];
4537 		if (alc880_is_fixed_pin(nid)) {
4538 			int idx = alc880_fixed_pin_idx(nid);
4539 			spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4540 			assigned[idx] = 1;
4541 		}
4542 	}
4543 	/* left pins can be connect to any audio widget */
4544 	for (i = 0; i < cfg->line_outs; i++) {
4545 		nid = cfg->line_out_pins[i];
4546 		if (alc880_is_fixed_pin(nid))
4547 			continue;
4548 		/* search for an empty channel */
4549 		for (j = 0; j < cfg->line_outs; j++) {
4550 			if (!assigned[j]) {
4551 				spec->multiout.dac_nids[i] =
4552 					alc880_idx_to_dac(j);
4553 				assigned[j] = 1;
4554 				break;
4555 			}
4556 		}
4557 	}
4558 	spec->multiout.num_dacs = cfg->line_outs;
4559 	return 0;
4560 }
4561 
4562 /* add playback controls from the parsed DAC table */
4563 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4564 					     const struct auto_pin_cfg *cfg)
4565 {
4566 	static const char *chname[4] = {
4567 		"Front", "Surround", NULL /*CLFE*/, "Side"
4568 	};
4569 	hda_nid_t nid;
4570 	int i, err;
4571 
4572 	for (i = 0; i < cfg->line_outs; i++) {
4573 		if (!spec->multiout.dac_nids[i])
4574 			continue;
4575 		nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4576 		if (i == 2) {
4577 			/* Center/LFE */
4578 			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4579 					      "Center",
4580 					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4581 							      HDA_OUTPUT));
4582 			if (err < 0)
4583 				return err;
4584 			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4585 					      "LFE",
4586 					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4587 							      HDA_OUTPUT));
4588 			if (err < 0)
4589 				return err;
4590 			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4591 					     "Center",
4592 					  HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4593 							      HDA_INPUT));
4594 			if (err < 0)
4595 				return err;
4596 			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4597 					     "LFE",
4598 					  HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4599 							      HDA_INPUT));
4600 			if (err < 0)
4601 				return err;
4602 		} else {
4603 			const char *pfx;
4604 			if (cfg->line_outs == 1 &&
4605 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4606 				pfx = "Speaker";
4607 			else
4608 				pfx = chname[i];
4609 			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4610 					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4611 							      HDA_OUTPUT));
4612 			if (err < 0)
4613 				return err;
4614 			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4615 					  HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4616 							      HDA_INPUT));
4617 			if (err < 0)
4618 				return err;
4619 		}
4620 	}
4621 	return 0;
4622 }
4623 
4624 /* add playback controls for speaker and HP outputs */
4625 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4626 					const char *pfx)
4627 {
4628 	hda_nid_t nid;
4629 	int err;
4630 
4631 	if (!pin)
4632 		return 0;
4633 
4634 	if (alc880_is_fixed_pin(pin)) {
4635 		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4636 		/* specify the DAC as the extra output */
4637 		if (!spec->multiout.hp_nid)
4638 			spec->multiout.hp_nid = nid;
4639 		else
4640 			spec->multiout.extra_out_nid[0] = nid;
4641 		/* control HP volume/switch on the output mixer amp */
4642 		nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4643 		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4644 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4645 		if (err < 0)
4646 			return err;
4647 		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4648 				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4649 		if (err < 0)
4650 			return err;
4651 	} else if (alc880_is_multi_pin(pin)) {
4652 		/* set manual connection */
4653 		/* we have only a switch on HP-out PIN */
4654 		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4655 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4656 		if (err < 0)
4657 			return err;
4658 	}
4659 	return 0;
4660 }
4661 
4662 /* create input playback/capture controls for the given pin */
4663 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4664 			    const char *ctlname,
4665 			    int idx, hda_nid_t mix_nid)
4666 {
4667 	int err;
4668 
4669 	err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4670 			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4671 	if (err < 0)
4672 		return err;
4673 	err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4674 			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4675 	if (err < 0)
4676 		return err;
4677 	return 0;
4678 }
4679 
4680 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4681 {
4682 	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4683 	return (pincap & AC_PINCAP_IN) != 0;
4684 }
4685 
4686 /* create playback/capture controls for input pins */
4687 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4688 				      const struct auto_pin_cfg *cfg,
4689 				      hda_nid_t mixer,
4690 				      hda_nid_t cap1, hda_nid_t cap2)
4691 {
4692 	struct alc_spec *spec = codec->spec;
4693 	struct hda_input_mux *imux = &spec->private_imux[0];
4694 	int i, err, idx;
4695 
4696 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4697 		hda_nid_t pin;
4698 
4699 		pin = cfg->input_pins[i];
4700 		if (!alc_is_input_pin(codec, pin))
4701 			continue;
4702 
4703 		if (mixer) {
4704 			idx = get_connection_index(codec, mixer, pin);
4705 			if (idx >= 0) {
4706 				err = new_analog_input(spec, pin,
4707 						       auto_pin_cfg_labels[i],
4708 						       idx, mixer);
4709 				if (err < 0)
4710 					return err;
4711 			}
4712 		}
4713 
4714 		if (!cap1)
4715 			continue;
4716 		idx = get_connection_index(codec, cap1, pin);
4717 		if (idx < 0 && cap2)
4718 			idx = get_connection_index(codec, cap2, pin);
4719 		if (idx >= 0) {
4720 			imux->items[imux->num_items].label =
4721 				auto_pin_cfg_labels[i];
4722 			imux->items[imux->num_items].index = idx;
4723 			imux->num_items++;
4724 		}
4725 	}
4726 	return 0;
4727 }
4728 
4729 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4730 						const struct auto_pin_cfg *cfg)
4731 {
4732 	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4733 }
4734 
4735 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4736 			       unsigned int pin_type)
4737 {
4738 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4739 			    pin_type);
4740 	/* unmute pin */
4741 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4742 			    AMP_OUT_UNMUTE);
4743 }
4744 
4745 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4746 					      hda_nid_t nid, int pin_type,
4747 					      int dac_idx)
4748 {
4749 	alc_set_pin_output(codec, nid, pin_type);
4750 	/* need the manual connection? */
4751 	if (alc880_is_multi_pin(nid)) {
4752 		struct alc_spec *spec = codec->spec;
4753 		int idx = alc880_multi_pin_idx(nid);
4754 		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4755 				    AC_VERB_SET_CONNECT_SEL,
4756 				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4757 	}
4758 }
4759 
4760 static int get_pin_type(int line_out_type)
4761 {
4762 	if (line_out_type == AUTO_PIN_HP_OUT)
4763 		return PIN_HP;
4764 	else
4765 		return PIN_OUT;
4766 }
4767 
4768 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4769 {
4770 	struct alc_spec *spec = codec->spec;
4771 	int i;
4772 
4773 	for (i = 0; i < spec->autocfg.line_outs; i++) {
4774 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
4775 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
4776 		alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4777 	}
4778 }
4779 
4780 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4781 {
4782 	struct alc_spec *spec = codec->spec;
4783 	hda_nid_t pin;
4784 
4785 	pin = spec->autocfg.speaker_pins[0];
4786 	if (pin) /* connect to front */
4787 		alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4788 	pin = spec->autocfg.hp_pins[0];
4789 	if (pin) /* connect to front */
4790 		alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4791 }
4792 
4793 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4794 {
4795 	struct alc_spec *spec = codec->spec;
4796 	int i;
4797 
4798 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4799 		hda_nid_t nid = spec->autocfg.input_pins[i];
4800 		if (alc_is_input_pin(codec, nid)) {
4801 			alc_set_input_pin(codec, nid, i);
4802 			if (nid != ALC880_PIN_CD_NID &&
4803 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4804 				snd_hda_codec_write(codec, nid, 0,
4805 						    AC_VERB_SET_AMP_GAIN_MUTE,
4806 						    AMP_OUT_MUTE);
4807 		}
4808 	}
4809 }
4810 
4811 /* parse the BIOS configuration and set up the alc_spec */
4812 /* return 1 if successful, 0 if the proper config is not found,
4813  * or a negative error code
4814  */
4815 static int alc880_parse_auto_config(struct hda_codec *codec)
4816 {
4817 	struct alc_spec *spec = codec->spec;
4818 	int i, err;
4819 	static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4820 
4821 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4822 					   alc880_ignore);
4823 	if (err < 0)
4824 		return err;
4825 	if (!spec->autocfg.line_outs)
4826 		return 0; /* can't find valid BIOS pin config */
4827 
4828 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4829 	if (err < 0)
4830 		return err;
4831 	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4832 	if (err < 0)
4833 		return err;
4834 	err = alc880_auto_create_extra_out(spec,
4835 					   spec->autocfg.speaker_pins[0],
4836 					   "Speaker");
4837 	if (err < 0)
4838 		return err;
4839 	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4840 					   "Headphone");
4841 	if (err < 0)
4842 		return err;
4843 	err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4844 	if (err < 0)
4845 		return err;
4846 
4847 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4848 
4849 	/* check multiple SPDIF-out (for recent codecs) */
4850 	for (i = 0; i < spec->autocfg.dig_outs; i++) {
4851 		hda_nid_t dig_nid;
4852 		err = snd_hda_get_connections(codec,
4853 					      spec->autocfg.dig_out_pins[i],
4854 					      &dig_nid, 1);
4855 		if (err < 0)
4856 			continue;
4857 		if (!i)
4858 			spec->multiout.dig_out_nid = dig_nid;
4859 		else {
4860 			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4861 			if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4862 				break;
4863 			spec->slave_dig_outs[i - 1] = dig_nid;
4864 		}
4865 	}
4866 	if (spec->autocfg.dig_in_pin)
4867 		spec->dig_in_nid = ALC880_DIGIN_NID;
4868 
4869 	if (spec->kctls.list)
4870 		add_mixer(spec, spec->kctls.list);
4871 
4872 	add_verb(spec, alc880_volume_init_verbs);
4873 
4874 	spec->num_mux_defs = 1;
4875 	spec->input_mux = &spec->private_imux[0];
4876 
4877 	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
4878 
4879 	return 1;
4880 }
4881 
4882 /* additional initialization for auto-configuration model */
4883 static void alc880_auto_init(struct hda_codec *codec)
4884 {
4885 	struct alc_spec *spec = codec->spec;
4886 	alc880_auto_init_multi_out(codec);
4887 	alc880_auto_init_extra_out(codec);
4888 	alc880_auto_init_analog_input(codec);
4889 	if (spec->unsol_event)
4890 		alc_inithook(codec);
4891 }
4892 
4893 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4894  * one of two digital mic pins, e.g. on ALC272
4895  */
4896 static void fixup_automic_adc(struct hda_codec *codec)
4897 {
4898 	struct alc_spec *spec = codec->spec;
4899 	int i;
4900 
4901 	for (i = 0; i < spec->num_adc_nids; i++) {
4902 		hda_nid_t cap = spec->capsrc_nids ?
4903 			spec->capsrc_nids[i] : spec->adc_nids[i];
4904 		int iidx, eidx;
4905 
4906 		iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4907 		if (iidx < 0)
4908 			continue;
4909 		eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4910 		if (eidx < 0)
4911 			continue;
4912 		spec->int_mic.mux_idx = iidx;
4913 		spec->ext_mic.mux_idx = eidx;
4914 		if (spec->capsrc_nids)
4915 			spec->capsrc_nids += i;
4916 		spec->adc_nids += i;
4917 		spec->num_adc_nids = 1;
4918 		return;
4919 	}
4920 	snd_printd(KERN_INFO "hda_codec: %s: "
4921 		   "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4922 		   codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4923 	spec->auto_mic = 0; /* disable auto-mic to be sure */
4924 }
4925 
4926 /* choose the ADC/MUX containing the input pin and initialize the setup */
4927 static void fixup_single_adc(struct hda_codec *codec)
4928 {
4929 	struct alc_spec *spec = codec->spec;
4930 	hda_nid_t pin = 0;
4931 	int i;
4932 
4933 	/* search for the input pin; there must be only one */
4934 	for (i = 0; i < AUTO_PIN_LAST; i++) {
4935 		if (spec->autocfg.input_pins[i]) {
4936 			pin = spec->autocfg.input_pins[i];
4937 			break;
4938 		}
4939 	}
4940 	if (!pin)
4941 		return;
4942 
4943 	/* set the default connection to that pin */
4944 	for (i = 0; i < spec->num_adc_nids; i++) {
4945 		hda_nid_t cap = spec->capsrc_nids ?
4946 			spec->capsrc_nids[i] : spec->adc_nids[i];
4947 		int idx;
4948 
4949 		idx = get_connection_index(codec, cap, pin);
4950 		if (idx < 0)
4951 			continue;
4952 		/* use only this ADC */
4953 		if (spec->capsrc_nids)
4954 			spec->capsrc_nids += i;
4955 		spec->adc_nids += i;
4956 		spec->num_adc_nids = 1;
4957 		/* select or unmute this route */
4958 		if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
4959 			snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
4960 						 HDA_AMP_MUTE, 0);
4961 		} else {
4962 			snd_hda_codec_write_cache(codec, cap, 0,
4963 					  AC_VERB_SET_CONNECT_SEL, idx);
4964 		}
4965 		return;
4966 	}
4967 }
4968 
4969 static void set_capture_mixer(struct hda_codec *codec)
4970 {
4971 	struct alc_spec *spec = codec->spec;
4972 	static struct snd_kcontrol_new *caps[2][3] = {
4973 		{ alc_capture_mixer_nosrc1,
4974 		  alc_capture_mixer_nosrc2,
4975 		  alc_capture_mixer_nosrc3 },
4976 		{ alc_capture_mixer1,
4977 		  alc_capture_mixer2,
4978 		  alc_capture_mixer3 },
4979 	};
4980 	if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4981 		int mux = 0;
4982 		if (spec->auto_mic)
4983 			fixup_automic_adc(codec);
4984 		else if (spec->input_mux) {
4985 			if (spec->input_mux->num_items > 1)
4986 				mux = 1;
4987 			else if (spec->input_mux->num_items == 1)
4988 				fixup_single_adc(codec);
4989 		}
4990 		spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4991 	}
4992 }
4993 
4994 /* fill adc_nids (and capsrc_nids) containing all active input pins */
4995 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
4996 				 int num_nids)
4997 {
4998 	struct alc_spec *spec = codec->spec;
4999 	int n;
5000 	hda_nid_t fallback_adc = 0, fallback_cap = 0;
5001 
5002 	for (n = 0; n < num_nids; n++) {
5003 		hda_nid_t adc, cap;
5004 		hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5005 		int nconns, i, j;
5006 
5007 		adc = nids[n];
5008 		if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5009 			continue;
5010 		cap = adc;
5011 		nconns = snd_hda_get_connections(codec, cap, conn,
5012 						 ARRAY_SIZE(conn));
5013 		if (nconns == 1) {
5014 			cap = conn[0];
5015 			nconns = snd_hda_get_connections(codec, cap, conn,
5016 							 ARRAY_SIZE(conn));
5017 		}
5018 		if (nconns <= 0)
5019 			continue;
5020 		if (!fallback_adc) {
5021 			fallback_adc = adc;
5022 			fallback_cap = cap;
5023 		}
5024 		for (i = 0; i < AUTO_PIN_LAST; i++) {
5025 			hda_nid_t nid = spec->autocfg.input_pins[i];
5026 			if (!nid)
5027 				continue;
5028 			for (j = 0; j < nconns; j++) {
5029 				if (conn[j] == nid)
5030 					break;
5031 			}
5032 			if (j >= nconns)
5033 				break;
5034 		}
5035 		if (i >= AUTO_PIN_LAST) {
5036 			int num_adcs = spec->num_adc_nids;
5037 			spec->private_adc_nids[num_adcs] = adc;
5038 			spec->private_capsrc_nids[num_adcs] = cap;
5039 			spec->num_adc_nids++;
5040 			spec->adc_nids = spec->private_adc_nids;
5041 			if (adc != cap)
5042 				spec->capsrc_nids = spec->private_capsrc_nids;
5043 		}
5044 	}
5045 	if (!spec->num_adc_nids) {
5046 		printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5047 		       " using fallback 0x%x\n",
5048 		       codec->chip_name, fallback_adc);
5049 		spec->private_adc_nids[0] = fallback_adc;
5050 		spec->adc_nids = spec->private_adc_nids;
5051 		if (fallback_adc != fallback_cap) {
5052 			spec->private_capsrc_nids[0] = fallback_cap;
5053 			spec->capsrc_nids = spec->private_adc_nids;
5054 		}
5055 	}
5056 }
5057 
5058 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5059 #define set_beep_amp(spec, nid, idx, dir) \
5060 	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5061 #else
5062 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5063 #endif
5064 
5065 /*
5066  * OK, here we have finally the patch for ALC880
5067  */
5068 
5069 static int patch_alc880(struct hda_codec *codec)
5070 {
5071 	struct alc_spec *spec;
5072 	int board_config;
5073 	int err;
5074 
5075 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5076 	if (spec == NULL)
5077 		return -ENOMEM;
5078 
5079 	codec->spec = spec;
5080 
5081 	board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5082 						  alc880_models,
5083 						  alc880_cfg_tbl);
5084 	if (board_config < 0) {
5085 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5086 		       codec->chip_name);
5087 		board_config = ALC880_AUTO;
5088 	}
5089 
5090 	if (board_config == ALC880_AUTO) {
5091 		/* automatic parse from the BIOS config */
5092 		err = alc880_parse_auto_config(codec);
5093 		if (err < 0) {
5094 			alc_free(codec);
5095 			return err;
5096 		} else if (!err) {
5097 			printk(KERN_INFO
5098 			       "hda_codec: Cannot set up configuration "
5099 			       "from BIOS.  Using 3-stack mode...\n");
5100 			board_config = ALC880_3ST;
5101 		}
5102 	}
5103 
5104 	err = snd_hda_attach_beep_device(codec, 0x1);
5105 	if (err < 0) {
5106 		alc_free(codec);
5107 		return err;
5108 	}
5109 
5110 	if (board_config != ALC880_AUTO)
5111 		setup_preset(codec, &alc880_presets[board_config]);
5112 
5113 	spec->stream_analog_playback = &alc880_pcm_analog_playback;
5114 	spec->stream_analog_capture = &alc880_pcm_analog_capture;
5115 	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5116 
5117 	spec->stream_digital_playback = &alc880_pcm_digital_playback;
5118 	spec->stream_digital_capture = &alc880_pcm_digital_capture;
5119 
5120 	if (!spec->adc_nids && spec->input_mux) {
5121 		/* check whether NID 0x07 is valid */
5122 		unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5123 		/* get type */
5124 		wcap = get_wcaps_type(wcap);
5125 		if (wcap != AC_WID_AUD_IN) {
5126 			spec->adc_nids = alc880_adc_nids_alt;
5127 			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5128 		} else {
5129 			spec->adc_nids = alc880_adc_nids;
5130 			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5131 		}
5132 	}
5133 	set_capture_mixer(codec);
5134 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5135 
5136 	spec->vmaster_nid = 0x0c;
5137 
5138 	codec->patch_ops = alc_patch_ops;
5139 	if (board_config == ALC880_AUTO)
5140 		spec->init_hook = alc880_auto_init;
5141 #ifdef CONFIG_SND_HDA_POWER_SAVE
5142 	if (!spec->loopback.amplist)
5143 		spec->loopback.amplist = alc880_loopbacks;
5144 #endif
5145 
5146 	return 0;
5147 }
5148 
5149 
5150 /*
5151  * ALC260 support
5152  */
5153 
5154 static hda_nid_t alc260_dac_nids[1] = {
5155 	/* front */
5156 	0x02,
5157 };
5158 
5159 static hda_nid_t alc260_adc_nids[1] = {
5160 	/* ADC0 */
5161 	0x04,
5162 };
5163 
5164 static hda_nid_t alc260_adc_nids_alt[1] = {
5165 	/* ADC1 */
5166 	0x05,
5167 };
5168 
5169 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5170  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5171  */
5172 static hda_nid_t alc260_dual_adc_nids[2] = {
5173 	/* ADC0, ADC1 */
5174 	0x04, 0x05
5175 };
5176 
5177 #define ALC260_DIGOUT_NID	0x03
5178 #define ALC260_DIGIN_NID	0x06
5179 
5180 static struct hda_input_mux alc260_capture_source = {
5181 	.num_items = 4,
5182 	.items = {
5183 		{ "Mic", 0x0 },
5184 		{ "Front Mic", 0x1 },
5185 		{ "Line", 0x2 },
5186 		{ "CD", 0x4 },
5187 	},
5188 };
5189 
5190 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5191  * headphone jack and the internal CD lines since these are the only pins at
5192  * which audio can appear.  For flexibility, also allow the option of
5193  * recording the mixer output on the second ADC (ADC0 doesn't have a
5194  * connection to the mixer output).
5195  */
5196 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5197 	{
5198 		.num_items = 3,
5199 		.items = {
5200 			{ "Mic/Line", 0x0 },
5201 			{ "CD", 0x4 },
5202 			{ "Headphone", 0x2 },
5203 		},
5204 	},
5205 	{
5206 		.num_items = 4,
5207 		.items = {
5208 			{ "Mic/Line", 0x0 },
5209 			{ "CD", 0x4 },
5210 			{ "Headphone", 0x2 },
5211 			{ "Mixer", 0x5 },
5212 		},
5213 	},
5214 
5215 };
5216 
5217 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5218  * the Fujitsu S702x, but jacks are marked differently.
5219  */
5220 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5221 	{
5222 		.num_items = 4,
5223 		.items = {
5224 			{ "Mic", 0x0 },
5225 			{ "Line", 0x2 },
5226 			{ "CD", 0x4 },
5227 			{ "Headphone", 0x5 },
5228 		},
5229 	},
5230 	{
5231 		.num_items = 5,
5232 		.items = {
5233 			{ "Mic", 0x0 },
5234 			{ "Line", 0x2 },
5235 			{ "CD", 0x4 },
5236 			{ "Headphone", 0x6 },
5237 			{ "Mixer", 0x5 },
5238 		},
5239 	},
5240 };
5241 
5242 /* Maxdata Favorit 100XS */
5243 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5244 	{
5245 		.num_items = 2,
5246 		.items = {
5247 			{ "Line/Mic", 0x0 },
5248 			{ "CD", 0x4 },
5249 		},
5250 	},
5251 	{
5252 		.num_items = 3,
5253 		.items = {
5254 			{ "Line/Mic", 0x0 },
5255 			{ "CD", 0x4 },
5256 			{ "Mixer", 0x5 },
5257 		},
5258 	},
5259 };
5260 
5261 /*
5262  * This is just place-holder, so there's something for alc_build_pcms to look
5263  * at when it calculates the maximum number of channels. ALC260 has no mixer
5264  * element which allows changing the channel mode, so the verb list is
5265  * never used.
5266  */
5267 static struct hda_channel_mode alc260_modes[1] = {
5268 	{ 2, NULL },
5269 };
5270 
5271 
5272 /* Mixer combinations
5273  *
5274  * basic: base_output + input + pc_beep + capture
5275  * HP: base_output + input + capture_alt
5276  * HP_3013: hp_3013 + input + capture
5277  * fujitsu: fujitsu + capture
5278  * acer: acer + capture
5279  */
5280 
5281 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5282 	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5283 	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5284 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5285 	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5286 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5287 	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5288 	{ } /* end */
5289 };
5290 
5291 static struct snd_kcontrol_new alc260_input_mixer[] = {
5292 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5293 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, 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 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5297 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5298 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5299 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5300 	{ } /* end */
5301 };
5302 
5303 /* update HP, line and mono out pins according to the master switch */
5304 static void alc260_hp_master_update(struct hda_codec *codec,
5305 				    hda_nid_t hp, hda_nid_t line,
5306 				    hda_nid_t mono)
5307 {
5308 	struct alc_spec *spec = codec->spec;
5309 	unsigned int val = spec->master_sw ? PIN_HP : 0;
5310 	/* change HP and line-out pins */
5311 	snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5312 			    val);
5313 	snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5314 			    val);
5315 	/* mono (speaker) depending on the HP jack sense */
5316 	val = (val && !spec->jack_present) ? PIN_OUT : 0;
5317 	snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5318 			    val);
5319 }
5320 
5321 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5322 				   struct snd_ctl_elem_value *ucontrol)
5323 {
5324 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5325 	struct alc_spec *spec = codec->spec;
5326 	*ucontrol->value.integer.value = spec->master_sw;
5327 	return 0;
5328 }
5329 
5330 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5331 				   struct snd_ctl_elem_value *ucontrol)
5332 {
5333 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5334 	struct alc_spec *spec = codec->spec;
5335 	int val = !!*ucontrol->value.integer.value;
5336 	hda_nid_t hp, line, mono;
5337 
5338 	if (val == spec->master_sw)
5339 		return 0;
5340 	spec->master_sw = val;
5341 	hp = (kcontrol->private_value >> 16) & 0xff;
5342 	line = (kcontrol->private_value >> 8) & 0xff;
5343 	mono = kcontrol->private_value & 0xff;
5344 	alc260_hp_master_update(codec, hp, line, mono);
5345 	return 1;
5346 }
5347 
5348 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5349 	{
5350 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5351 		.name = "Master Playback Switch",
5352 		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5353 		.info = snd_ctl_boolean_mono_info,
5354 		.get = alc260_hp_master_sw_get,
5355 		.put = alc260_hp_master_sw_put,
5356 		.private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5357 	},
5358 	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5359 	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5360 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5361 	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5362 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5363 			      HDA_OUTPUT),
5364 	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5365 	{ } /* end */
5366 };
5367 
5368 static struct hda_verb alc260_hp_unsol_verbs[] = {
5369 	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5370 	{},
5371 };
5372 
5373 static void alc260_hp_automute(struct hda_codec *codec)
5374 {
5375 	struct alc_spec *spec = codec->spec;
5376 
5377 	spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5378 	alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5379 }
5380 
5381 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5382 {
5383 	if ((res >> 26) == ALC880_HP_EVENT)
5384 		alc260_hp_automute(codec);
5385 }
5386 
5387 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5388 	{
5389 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5390 		.name = "Master Playback Switch",
5391 		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5392 		.info = snd_ctl_boolean_mono_info,
5393 		.get = alc260_hp_master_sw_get,
5394 		.put = alc260_hp_master_sw_put,
5395 		.private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5396 	},
5397 	HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5398 	HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5399 	HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5400 	HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5401 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5402 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5403 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5404 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5405 	{ } /* end */
5406 };
5407 
5408 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5409 	.ops = &snd_hda_bind_vol,
5410 	.values = {
5411 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5412 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5413 		HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5414 		0
5415 	},
5416 };
5417 
5418 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5419 	.ops = &snd_hda_bind_sw,
5420 	.values = {
5421 		HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5422 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5423 		0
5424 	},
5425 };
5426 
5427 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5428 	HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5429 	HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5430 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5431 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5432 	{ } /* end */
5433 };
5434 
5435 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5436 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5437 	{},
5438 };
5439 
5440 static void alc260_hp_3013_automute(struct hda_codec *codec)
5441 {
5442 	struct alc_spec *spec = codec->spec;
5443 
5444 	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5445 	alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5446 }
5447 
5448 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5449 				       unsigned int res)
5450 {
5451 	if ((res >> 26) == ALC880_HP_EVENT)
5452 		alc260_hp_3013_automute(codec);
5453 }
5454 
5455 static void alc260_hp_3012_automute(struct hda_codec *codec)
5456 {
5457 	unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5458 
5459 	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5460 			    bits);
5461 	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5462 			    bits);
5463 	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5464 			    bits);
5465 }
5466 
5467 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5468 				       unsigned int res)
5469 {
5470 	if ((res >> 26) == ALC880_HP_EVENT)
5471 		alc260_hp_3012_automute(codec);
5472 }
5473 
5474 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5475  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5476  */
5477 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5478 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5479 	HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5480 	ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5481 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5482 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5483 	HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5484 	HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5485 	ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5486 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5487 	HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5488 	{ } /* end */
5489 };
5490 
5491 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5492  * versions of the ALC260 don't act on requests to enable mic bias from NID
5493  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5494  * datasheet doesn't mention this restriction.  At this stage it's not clear
5495  * whether this behaviour is intentional or is a hardware bug in chip
5496  * revisions available in early 2006.  Therefore for now allow the
5497  * "Headphone Jack Mode" control to span all choices, but if it turns out
5498  * that the lack of mic bias for this NID is intentional we could change the
5499  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5500  *
5501  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5502  * don't appear to make the mic bias available from the "line" jack, even
5503  * though the NID used for this jack (0x14) can supply it.  The theory is
5504  * that perhaps Acer have included blocking capacitors between the ALC260
5505  * and the output jack.  If this turns out to be the case for all such
5506  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5507  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5508  *
5509  * The C20x Tablet series have a mono internal speaker which is controlled
5510  * via the chip's Mono sum widget and pin complex, so include the necessary
5511  * controls for such models.  On models without a "mono speaker" the control
5512  * won't do anything.
5513  */
5514 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5515 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5516 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5517 	ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5518 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5519 			      HDA_OUTPUT),
5520 	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5521 			   HDA_INPUT),
5522 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5523 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5524 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5525 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5526 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5527 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5528 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5529 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5530 	{ } /* end */
5531 };
5532 
5533 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5534  */
5535 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5536 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5537 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5538 	ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5539 	HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5540 	HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5541 	ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5542 	{ } /* end */
5543 };
5544 
5545 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5546  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5547  */
5548 static struct snd_kcontrol_new alc260_will_mixer[] = {
5549 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5550 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5551 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5552 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5553 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5554 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5555 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5556 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5557 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5558 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5559 	{ } /* end */
5560 };
5561 
5562 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5563  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5564  */
5565 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5566 	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5567 	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5568 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5569 	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5570 	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5571 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5572 	HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5573 	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5574 	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5575 	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5576 	{ } /* end */
5577 };
5578 
5579 /*
5580  * initialization verbs
5581  */
5582 static struct hda_verb alc260_init_verbs[] = {
5583 	/* Line In pin widget for input */
5584 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5585 	/* CD pin widget for input */
5586 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5587 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
5588 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5589 	/* Mic2 (front panel) pin widget for input and vref at 80% */
5590 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5591 	/* LINE-2 is used for line-out in rear */
5592 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5593 	/* select line-out */
5594 	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5595 	/* LINE-OUT pin */
5596 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5597 	/* enable HP */
5598 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5599 	/* enable Mono */
5600 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5601 	/* mute capture amp left and right */
5602 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5603 	/* set connection select to line in (default select for this ADC) */
5604 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5605 	/* mute capture amp left and right */
5606 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5607 	/* set connection select to line in (default select for this ADC) */
5608 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5609 	/* set vol=0 Line-Out mixer amp left and right */
5610 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5611 	/* unmute pin widget amp left and right (no gain on this amp) */
5612 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5613 	/* set vol=0 HP mixer amp left and right */
5614 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5615 	/* unmute pin widget amp left and right (no gain on this amp) */
5616 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5617 	/* set vol=0 Mono mixer amp left and right */
5618 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5619 	/* unmute pin widget amp left and right (no gain on this amp) */
5620 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5621 	/* unmute LINE-2 out pin */
5622 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5623 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5624 	 * Line In 2 = 0x03
5625 	 */
5626 	/* mute analog inputs */
5627 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5628 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5629 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5630 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5631 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5632 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5633 	/* mute Front out path */
5634 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5635 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5636 	/* mute Headphone out path */
5637 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5638 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5639 	/* mute Mono out path */
5640 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5641 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5642 	{ }
5643 };
5644 
5645 #if 0 /* should be identical with alc260_init_verbs? */
5646 static struct hda_verb alc260_hp_init_verbs[] = {
5647 	/* Headphone and output */
5648 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5649 	/* mono output */
5650 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5651 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
5652 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5653 	/* Mic2 (front panel) pin widget for input and vref at 80% */
5654 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5655 	/* Line In pin widget for input */
5656 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5657 	/* Line-2 pin widget for output */
5658 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5659 	/* CD pin widget for input */
5660 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5661 	/* unmute amp left and right */
5662 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5663 	/* set connection select to line in (default select for this ADC) */
5664 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5665 	/* unmute Line-Out mixer amp left and right (volume = 0) */
5666 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5667 	/* mute pin widget amp left and right (no gain on this amp) */
5668 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5669 	/* unmute HP mixer amp left and right (volume = 0) */
5670 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5671 	/* mute pin widget amp left and right (no gain on this amp) */
5672 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5673 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5674 	 * Line In 2 = 0x03
5675 	 */
5676 	/* mute analog inputs */
5677 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5678 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5679 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5680 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5681 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5682 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5683 	/* Unmute Front out path */
5684 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5685 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5686 	/* Unmute Headphone out path */
5687 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5688 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5689 	/* Unmute Mono out path */
5690 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5691 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5692 	{ }
5693 };
5694 #endif
5695 
5696 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5697 	/* Line out and output */
5698 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5699 	/* mono output */
5700 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5701 	/* Mic1 (rear panel) pin widget for input and vref at 80% */
5702 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5703 	/* Mic2 (front panel) pin widget for input and vref at 80% */
5704 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5705 	/* Line In pin widget for input */
5706 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5707 	/* Headphone pin widget for output */
5708 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5709 	/* CD pin widget for input */
5710 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5711 	/* unmute amp left and right */
5712 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5713 	/* set connection select to line in (default select for this ADC) */
5714 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5715 	/* unmute Line-Out mixer amp left and right (volume = 0) */
5716 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5717 	/* mute pin widget amp left and right (no gain on this amp) */
5718 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5719 	/* unmute HP mixer amp left and right (volume = 0) */
5720 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5721 	/* mute pin widget amp left and right (no gain on this amp) */
5722 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5723 	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5724 	 * Line In 2 = 0x03
5725 	 */
5726 	/* mute analog inputs */
5727 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5728 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5729 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5730 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5731 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5732 	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5733 	/* Unmute Front out path */
5734 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5735 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5736 	/* Unmute Headphone out path */
5737 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5738 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5739 	/* Unmute Mono out path */
5740 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5741 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5742 	{ }
5743 };
5744 
5745 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5746  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5747  * audio = 0x16, internal speaker = 0x10.
5748  */
5749 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5750 	/* Disable all GPIOs */
5751 	{0x01, AC_VERB_SET_GPIO_MASK, 0},
5752 	/* Internal speaker is connected to headphone pin */
5753 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5754 	/* Headphone/Line-out jack connects to Line1 pin; make it an output */
5755 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5756 	/* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5757 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5758 	/* Ensure all other unused pins are disabled and muted. */
5759 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5760 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5761 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5762 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5763 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5764 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5765 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5766 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5767 
5768 	/* Disable digital (SPDIF) pins */
5769 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5770 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5771 
5772 	/* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5773 	 * when acting as an output.
5774 	 */
5775 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5776 
5777 	/* Start with output sum widgets muted and their output gains at min */
5778 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5779 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5780 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5781 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5782 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5783 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5784 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5785 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5786 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5787 
5788 	/* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5789 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5790 	/* Unmute Line1 pin widget output buffer since it starts as an output.
5791 	 * If the pin mode is changed by the user the pin mode control will
5792 	 * take care of enabling the pin's input/output buffers as needed.
5793 	 * Therefore there's no need to enable the input buffer at this
5794 	 * stage.
5795 	 */
5796 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5797 	/* Unmute input buffer of pin widget used for Line-in (no equiv
5798 	 * mixer ctrl)
5799 	 */
5800 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5801 
5802 	/* Mute capture amp left and right */
5803 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5804 	/* Set ADC connection select to match default mixer setting - line
5805 	 * in (on mic1 pin)
5806 	 */
5807 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5808 
5809 	/* Do the same for the second ADC: mute capture input amp and
5810 	 * set ADC connection to line in (on mic1 pin)
5811 	 */
5812 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5813 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5814 
5815 	/* Mute all inputs to mixer widget (even unconnected ones) */
5816 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5817 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5818 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5819 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5820 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5821 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5822 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5823 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5824 
5825 	{ }
5826 };
5827 
5828 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5829  * similar laptops (adapted from Fujitsu init verbs).
5830  */
5831 static struct hda_verb alc260_acer_init_verbs[] = {
5832 	/* On TravelMate laptops, GPIO 0 enables the internal speaker and
5833 	 * the headphone jack.  Turn this on and rely on the standard mute
5834 	 * methods whenever the user wants to turn these outputs off.
5835 	 */
5836 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5837 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5838 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5839 	/* Internal speaker/Headphone jack is connected to Line-out pin */
5840 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5841 	/* Internal microphone/Mic jack is connected to Mic1 pin */
5842 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5843 	/* Line In jack is connected to Line1 pin */
5844 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5845 	/* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5846 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5847 	/* Ensure all other unused pins are disabled and muted. */
5848 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5849 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5850 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5851 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5852 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5853 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5854 	/* Disable digital (SPDIF) pins */
5855 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5856 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5857 
5858 	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5859 	 * bus when acting as outputs.
5860 	 */
5861 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5862 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5863 
5864 	/* Start with output sum widgets muted and their output gains at min */
5865 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5866 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5867 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5868 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5869 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5870 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5871 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5872 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5873 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5874 
5875 	/* Unmute Line-out pin widget amp left and right
5876 	 * (no equiv mixer ctrl)
5877 	 */
5878 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5879 	/* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5880 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5881 	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
5882 	 * inputs. If the pin mode is changed by the user the pin mode control
5883 	 * will take care of enabling the pin's input/output buffers as needed.
5884 	 * Therefore there's no need to enable the input buffer at this
5885 	 * stage.
5886 	 */
5887 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5888 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5889 
5890 	/* Mute capture amp left and right */
5891 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5892 	/* Set ADC connection select to match default mixer setting - mic
5893 	 * (on mic1 pin)
5894 	 */
5895 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5896 
5897 	/* Do similar with the second ADC: mute capture input amp and
5898 	 * set ADC connection to mic to match ALSA's default state.
5899 	 */
5900 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5901 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5902 
5903 	/* Mute all inputs to mixer widget (even unconnected ones) */
5904 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5905 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5906 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5907 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5908 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5909 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5910 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5911 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5912 
5913 	{ }
5914 };
5915 
5916 /* Initialisation sequence for Maxdata Favorit 100XS
5917  * (adapted from Acer init verbs).
5918  */
5919 static struct hda_verb alc260_favorit100_init_verbs[] = {
5920 	/* GPIO 0 enables the output jack.
5921 	 * Turn this on and rely on the standard mute
5922 	 * methods whenever the user wants to turn these outputs off.
5923 	 */
5924 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5925 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5926 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5927 	/* Line/Mic input jack is connected to Mic1 pin */
5928 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5929 	/* Ensure all other unused pins are disabled and muted. */
5930 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5931 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5932 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5933 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5934 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5935 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5936 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5937 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5938 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5939 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5940 	/* Disable digital (SPDIF) pins */
5941 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5942 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5943 
5944 	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5945 	 * bus when acting as outputs.
5946 	 */
5947 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5948 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5949 
5950 	/* Start with output sum widgets muted and their output gains at min */
5951 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5952 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5953 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5954 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5955 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5956 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5957 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5958 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5959 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5960 
5961 	/* Unmute Line-out pin widget amp left and right
5962 	 * (no equiv mixer ctrl)
5963 	 */
5964 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5965 	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
5966 	 * inputs. If the pin mode is changed by the user the pin mode control
5967 	 * will take care of enabling the pin's input/output buffers as needed.
5968 	 * Therefore there's no need to enable the input buffer at this
5969 	 * stage.
5970 	 */
5971 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5972 
5973 	/* Mute capture amp left and right */
5974 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5975 	/* Set ADC connection select to match default mixer setting - mic
5976 	 * (on mic1 pin)
5977 	 */
5978 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5979 
5980 	/* Do similar with the second ADC: mute capture input amp and
5981 	 * set ADC connection to mic to match ALSA's default state.
5982 	 */
5983 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5984 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5985 
5986 	/* Mute all inputs to mixer widget (even unconnected ones) */
5987 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5988 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5989 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5990 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5991 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5992 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5993 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5994 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5995 
5996 	{ }
5997 };
5998 
5999 static struct hda_verb alc260_will_verbs[] = {
6000 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6001 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6002 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6003 	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6004 	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6005 	{0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6006 	{}
6007 };
6008 
6009 static struct hda_verb alc260_replacer_672v_verbs[] = {
6010 	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6011 	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6012 	{0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6013 
6014 	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6015 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6016 	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6017 
6018 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6019 	{}
6020 };
6021 
6022 /* toggle speaker-output according to the hp-jack state */
6023 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6024 {
6025         unsigned int present;
6026 
6027 	/* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6028 	present = snd_hda_jack_detect(codec, 0x0f);
6029 	if (present) {
6030 		snd_hda_codec_write_cache(codec, 0x01, 0,
6031 					  AC_VERB_SET_GPIO_DATA, 1);
6032 		snd_hda_codec_write_cache(codec, 0x0f, 0,
6033 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6034 					  PIN_HP);
6035 	} else {
6036 		snd_hda_codec_write_cache(codec, 0x01, 0,
6037 					  AC_VERB_SET_GPIO_DATA, 0);
6038 		snd_hda_codec_write_cache(codec, 0x0f, 0,
6039 					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6040 					  PIN_OUT);
6041 	}
6042 }
6043 
6044 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6045                                        unsigned int res)
6046 {
6047         if ((res >> 26) == ALC880_HP_EVENT)
6048                 alc260_replacer_672v_automute(codec);
6049 }
6050 
6051 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6052 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6053 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6054 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6055 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6056 	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6057 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6058 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6059 	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6060 	{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6061 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6062 	{}
6063 };
6064 
6065 /* Test configuration for debugging, modelled after the ALC880 test
6066  * configuration.
6067  */
6068 #ifdef CONFIG_SND_DEBUG
6069 static hda_nid_t alc260_test_dac_nids[1] = {
6070 	0x02,
6071 };
6072 static hda_nid_t alc260_test_adc_nids[2] = {
6073 	0x04, 0x05,
6074 };
6075 /* For testing the ALC260, each input MUX needs its own definition since
6076  * the signal assignments are different.  This assumes that the first ADC
6077  * is NID 0x04.
6078  */
6079 static struct hda_input_mux alc260_test_capture_sources[2] = {
6080 	{
6081 		.num_items = 7,
6082 		.items = {
6083 			{ "MIC1 pin", 0x0 },
6084 			{ "MIC2 pin", 0x1 },
6085 			{ "LINE1 pin", 0x2 },
6086 			{ "LINE2 pin", 0x3 },
6087 			{ "CD pin", 0x4 },
6088 			{ "LINE-OUT pin", 0x5 },
6089 			{ "HP-OUT pin", 0x6 },
6090 		},
6091         },
6092 	{
6093 		.num_items = 8,
6094 		.items = {
6095 			{ "MIC1 pin", 0x0 },
6096 			{ "MIC2 pin", 0x1 },
6097 			{ "LINE1 pin", 0x2 },
6098 			{ "LINE2 pin", 0x3 },
6099 			{ "CD pin", 0x4 },
6100 			{ "Mixer", 0x5 },
6101 			{ "LINE-OUT pin", 0x6 },
6102 			{ "HP-OUT pin", 0x7 },
6103 		},
6104         },
6105 };
6106 static struct snd_kcontrol_new alc260_test_mixer[] = {
6107 	/* Output driver widgets */
6108 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6109 	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6110 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6111 	HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6112 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6113 	HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6114 
6115 	/* Modes for retasking pin widgets
6116 	 * Note: the ALC260 doesn't seem to act on requests to enable mic
6117          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6118          * mention this restriction.  At this stage it's not clear whether
6119          * this behaviour is intentional or is a hardware bug in chip
6120          * revisions available at least up until early 2006.  Therefore for
6121          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6122          * choices, but if it turns out that the lack of mic bias for these
6123          * NIDs is intentional we could change their modes from
6124          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6125 	 */
6126 	ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6127 	ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6128 	ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6129 	ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6130 	ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6131 	ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6132 
6133 	/* Loopback mixer controls */
6134 	HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6135 	HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6136 	HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6137 	HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6138 	HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6139 	HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6140 	HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6141 	HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6142 	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6143 	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6144 	HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6145 	HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6146 	HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6147 	HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6148 
6149 	/* Controls for GPIO pins, assuming they are configured as outputs */
6150 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6151 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6152 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6153 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6154 
6155 	/* Switches to allow the digital IO pins to be enabled.  The datasheet
6156 	 * is ambigious as to which NID is which; testing on laptops which
6157 	 * make this output available should provide clarification.
6158 	 */
6159 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6160 	ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6161 
6162 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
6163 	 * this output to turn on an external amplifier.
6164 	 */
6165 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6166 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6167 
6168 	{ } /* end */
6169 };
6170 static struct hda_verb alc260_test_init_verbs[] = {
6171 	/* Enable all GPIOs as outputs with an initial value of 0 */
6172 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6173 	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6174 	{0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6175 
6176 	/* Enable retasking pins as output, initially without power amp */
6177 	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6178 	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6179 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6180 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6181 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6182 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6183 
6184 	/* Disable digital (SPDIF) pins initially, but users can enable
6185 	 * them via a mixer switch.  In the case of SPDIF-out, this initverb
6186 	 * payload also sets the generation to 0, output to be in "consumer"
6187 	 * PCM format, copyright asserted, no pre-emphasis and no validity
6188 	 * control.
6189 	 */
6190 	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6191 	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6192 
6193 	/* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6194 	 * OUT1 sum bus when acting as an output.
6195 	 */
6196 	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6197 	{0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6198 	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6199 	{0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6200 
6201 	/* Start with output sum widgets muted and their output gains at min */
6202 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6203 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6204 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6205 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6206 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6207 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6208 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6209 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6210 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6211 
6212 	/* Unmute retasking pin widget output buffers since the default
6213 	 * state appears to be output.  As the pin mode is changed by the
6214 	 * user the pin mode control will take care of enabling the pin's
6215 	 * input/output buffers as needed.
6216 	 */
6217 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6218 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6219 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6220 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6221 	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6222 	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6223 	/* Also unmute the mono-out pin widget */
6224 	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6225 
6226 	/* Mute capture amp left and right */
6227 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6228 	/* Set ADC connection select to match default mixer setting (mic1
6229 	 * pin)
6230 	 */
6231 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6232 
6233 	/* Do the same for the second ADC: mute capture input amp and
6234 	 * set ADC connection to mic1 pin
6235 	 */
6236 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6237 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6238 
6239 	/* Mute all inputs to mixer widget (even unconnected ones) */
6240 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6241 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6242 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6243 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6244 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6245 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6246 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6247 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6248 
6249 	{ }
6250 };
6251 #endif
6252 
6253 #define alc260_pcm_analog_playback	alc880_pcm_analog_alt_playback
6254 #define alc260_pcm_analog_capture	alc880_pcm_analog_capture
6255 
6256 #define alc260_pcm_digital_playback	alc880_pcm_digital_playback
6257 #define alc260_pcm_digital_capture	alc880_pcm_digital_capture
6258 
6259 /*
6260  * for BIOS auto-configuration
6261  */
6262 
6263 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6264 					const char *pfx, int *vol_bits)
6265 {
6266 	hda_nid_t nid_vol;
6267 	unsigned long vol_val, sw_val;
6268 	int err;
6269 
6270 	if (nid >= 0x0f && nid < 0x11) {
6271 		nid_vol = nid - 0x7;
6272 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6273 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6274 	} else if (nid == 0x11) {
6275 		nid_vol = nid - 0x7;
6276 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6277 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6278 	} else if (nid >= 0x12 && nid <= 0x15) {
6279 		nid_vol = 0x08;
6280 		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6281 		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6282 	} else
6283 		return 0; /* N/A */
6284 
6285 	if (!(*vol_bits & (1 << nid_vol))) {
6286 		/* first control for the volume widget */
6287 		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6288 		if (err < 0)
6289 			return err;
6290 		*vol_bits |= (1 << nid_vol);
6291 	}
6292 	err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6293 	if (err < 0)
6294 		return err;
6295 	return 1;
6296 }
6297 
6298 /* add playback controls from the parsed DAC table */
6299 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6300 					     const struct auto_pin_cfg *cfg)
6301 {
6302 	hda_nid_t nid;
6303 	int err;
6304 	int vols = 0;
6305 
6306 	spec->multiout.num_dacs = 1;
6307 	spec->multiout.dac_nids = spec->private_dac_nids;
6308 	spec->multiout.dac_nids[0] = 0x02;
6309 
6310 	nid = cfg->line_out_pins[0];
6311 	if (nid) {
6312 		const char *pfx;
6313 		if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6314 			pfx = "Master";
6315 		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6316 			pfx = "Speaker";
6317 		else
6318 			pfx = "Front";
6319 		err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6320 		if (err < 0)
6321 			return err;
6322 	}
6323 
6324 	nid = cfg->speaker_pins[0];
6325 	if (nid) {
6326 		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6327 		if (err < 0)
6328 			return err;
6329 	}
6330 
6331 	nid = cfg->hp_pins[0];
6332 	if (nid) {
6333 		err = alc260_add_playback_controls(spec, nid, "Headphone",
6334 						   &vols);
6335 		if (err < 0)
6336 			return err;
6337 	}
6338 	return 0;
6339 }
6340 
6341 /* create playback/capture controls for input pins */
6342 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6343 						const struct auto_pin_cfg *cfg)
6344 {
6345 	return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6346 }
6347 
6348 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6349 					      hda_nid_t nid, int pin_type,
6350 					      int sel_idx)
6351 {
6352 	alc_set_pin_output(codec, nid, pin_type);
6353 	/* need the manual connection? */
6354 	if (nid >= 0x12) {
6355 		int idx = nid - 0x12;
6356 		snd_hda_codec_write(codec, idx + 0x0b, 0,
6357 				    AC_VERB_SET_CONNECT_SEL, sel_idx);
6358 	}
6359 }
6360 
6361 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6362 {
6363 	struct alc_spec *spec = codec->spec;
6364 	hda_nid_t nid;
6365 
6366 	nid = spec->autocfg.line_out_pins[0];
6367 	if (nid) {
6368 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
6369 		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6370 	}
6371 
6372 	nid = spec->autocfg.speaker_pins[0];
6373 	if (nid)
6374 		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6375 
6376 	nid = spec->autocfg.hp_pins[0];
6377 	if (nid)
6378 		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6379 }
6380 
6381 #define ALC260_PIN_CD_NID		0x16
6382 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6383 {
6384 	struct alc_spec *spec = codec->spec;
6385 	int i;
6386 
6387 	for (i = 0; i < AUTO_PIN_LAST; i++) {
6388 		hda_nid_t nid = spec->autocfg.input_pins[i];
6389 		if (nid >= 0x12) {
6390 			alc_set_input_pin(codec, nid, i);
6391 			if (nid != ALC260_PIN_CD_NID &&
6392 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6393 				snd_hda_codec_write(codec, nid, 0,
6394 						    AC_VERB_SET_AMP_GAIN_MUTE,
6395 						    AMP_OUT_MUTE);
6396 		}
6397 	}
6398 }
6399 
6400 /*
6401  * generic initialization of ADC, input mixers and output mixers
6402  */
6403 static struct hda_verb alc260_volume_init_verbs[] = {
6404 	/*
6405 	 * Unmute ADC0-1 and set the default input to mic-in
6406 	 */
6407 	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6408 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6409 	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6410 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6411 
6412 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6413 	 * mixer widget
6414 	 * Note: PASD motherboards uses the Line In 2 as the input for
6415 	 * front panel mic (mic 2)
6416 	 */
6417 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6418 	/* mute analog inputs */
6419 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6420 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6421 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6422 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6423 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6424 
6425 	/*
6426 	 * Set up output mixers (0x08 - 0x0a)
6427 	 */
6428 	/* set vol=0 to output mixers */
6429 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6430 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6431 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6432 	/* set up input amps for analog loopback */
6433 	/* Amp Indices: DAC = 0, mixer = 1 */
6434 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6435 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6436 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6437 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6438 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6439 	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6440 
6441 	{ }
6442 };
6443 
6444 static int alc260_parse_auto_config(struct hda_codec *codec)
6445 {
6446 	struct alc_spec *spec = codec->spec;
6447 	int err;
6448 	static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6449 
6450 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6451 					   alc260_ignore);
6452 	if (err < 0)
6453 		return err;
6454 	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6455 	if (err < 0)
6456 		return err;
6457 	if (!spec->kctls.list)
6458 		return 0; /* can't find valid BIOS pin config */
6459 	err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6460 	if (err < 0)
6461 		return err;
6462 
6463 	spec->multiout.max_channels = 2;
6464 
6465 	if (spec->autocfg.dig_outs)
6466 		spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6467 	if (spec->kctls.list)
6468 		add_mixer(spec, spec->kctls.list);
6469 
6470 	add_verb(spec, alc260_volume_init_verbs);
6471 
6472 	spec->num_mux_defs = 1;
6473 	spec->input_mux = &spec->private_imux[0];
6474 
6475 	alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6476 
6477 	return 1;
6478 }
6479 
6480 /* additional initialization for auto-configuration model */
6481 static void alc260_auto_init(struct hda_codec *codec)
6482 {
6483 	struct alc_spec *spec = codec->spec;
6484 	alc260_auto_init_multi_out(codec);
6485 	alc260_auto_init_analog_input(codec);
6486 	if (spec->unsol_event)
6487 		alc_inithook(codec);
6488 }
6489 
6490 #ifdef CONFIG_SND_HDA_POWER_SAVE
6491 static struct hda_amp_list alc260_loopbacks[] = {
6492 	{ 0x07, HDA_INPUT, 0 },
6493 	{ 0x07, HDA_INPUT, 1 },
6494 	{ 0x07, HDA_INPUT, 2 },
6495 	{ 0x07, HDA_INPUT, 3 },
6496 	{ 0x07, HDA_INPUT, 4 },
6497 	{ } /* end */
6498 };
6499 #endif
6500 
6501 /*
6502  * ALC260 configurations
6503  */
6504 static const char *alc260_models[ALC260_MODEL_LAST] = {
6505 	[ALC260_BASIC]		= "basic",
6506 	[ALC260_HP]		= "hp",
6507 	[ALC260_HP_3013]	= "hp-3013",
6508 	[ALC260_HP_DC7600]	= "hp-dc7600",
6509 	[ALC260_FUJITSU_S702X]	= "fujitsu",
6510 	[ALC260_ACER]		= "acer",
6511 	[ALC260_WILL]		= "will",
6512 	[ALC260_REPLACER_672V]	= "replacer",
6513 	[ALC260_FAVORIT100]	= "favorit100",
6514 #ifdef CONFIG_SND_DEBUG
6515 	[ALC260_TEST]		= "test",
6516 #endif
6517 	[ALC260_AUTO]		= "auto",
6518 };
6519 
6520 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6521 	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6522 	SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6523 	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6524 	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6525 	SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6526 	SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6527 	SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6528 	SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6529 	SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6530 	SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6531 	SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6532 	SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6533 	SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6534 	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6535 	SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6536 	SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6537 	SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6538 	SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6539 	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6540 	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6541 	{}
6542 };
6543 
6544 static struct alc_config_preset alc260_presets[] = {
6545 	[ALC260_BASIC] = {
6546 		.mixers = { alc260_base_output_mixer,
6547 			    alc260_input_mixer },
6548 		.init_verbs = { alc260_init_verbs },
6549 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6550 		.dac_nids = alc260_dac_nids,
6551 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6552 		.adc_nids = alc260_dual_adc_nids,
6553 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6554 		.channel_mode = alc260_modes,
6555 		.input_mux = &alc260_capture_source,
6556 	},
6557 	[ALC260_HP] = {
6558 		.mixers = { alc260_hp_output_mixer,
6559 			    alc260_input_mixer },
6560 		.init_verbs = { alc260_init_verbs,
6561 				alc260_hp_unsol_verbs },
6562 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6563 		.dac_nids = alc260_dac_nids,
6564 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6565 		.adc_nids = alc260_adc_nids_alt,
6566 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6567 		.channel_mode = alc260_modes,
6568 		.input_mux = &alc260_capture_source,
6569 		.unsol_event = alc260_hp_unsol_event,
6570 		.init_hook = alc260_hp_automute,
6571 	},
6572 	[ALC260_HP_DC7600] = {
6573 		.mixers = { alc260_hp_dc7600_mixer,
6574 			    alc260_input_mixer },
6575 		.init_verbs = { alc260_init_verbs,
6576 				alc260_hp_dc7600_verbs },
6577 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6578 		.dac_nids = alc260_dac_nids,
6579 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6580 		.adc_nids = alc260_adc_nids_alt,
6581 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6582 		.channel_mode = alc260_modes,
6583 		.input_mux = &alc260_capture_source,
6584 		.unsol_event = alc260_hp_3012_unsol_event,
6585 		.init_hook = alc260_hp_3012_automute,
6586 	},
6587 	[ALC260_HP_3013] = {
6588 		.mixers = { alc260_hp_3013_mixer,
6589 			    alc260_input_mixer },
6590 		.init_verbs = { alc260_hp_3013_init_verbs,
6591 				alc260_hp_3013_unsol_verbs },
6592 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6593 		.dac_nids = alc260_dac_nids,
6594 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6595 		.adc_nids = alc260_adc_nids_alt,
6596 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6597 		.channel_mode = alc260_modes,
6598 		.input_mux = &alc260_capture_source,
6599 		.unsol_event = alc260_hp_3013_unsol_event,
6600 		.init_hook = alc260_hp_3013_automute,
6601 	},
6602 	[ALC260_FUJITSU_S702X] = {
6603 		.mixers = { alc260_fujitsu_mixer },
6604 		.init_verbs = { alc260_fujitsu_init_verbs },
6605 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6606 		.dac_nids = alc260_dac_nids,
6607 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6608 		.adc_nids = alc260_dual_adc_nids,
6609 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6610 		.channel_mode = alc260_modes,
6611 		.num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6612 		.input_mux = alc260_fujitsu_capture_sources,
6613 	},
6614 	[ALC260_ACER] = {
6615 		.mixers = { alc260_acer_mixer },
6616 		.init_verbs = { alc260_acer_init_verbs },
6617 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6618 		.dac_nids = alc260_dac_nids,
6619 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6620 		.adc_nids = alc260_dual_adc_nids,
6621 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6622 		.channel_mode = alc260_modes,
6623 		.num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6624 		.input_mux = alc260_acer_capture_sources,
6625 	},
6626 	[ALC260_FAVORIT100] = {
6627 		.mixers = { alc260_favorit100_mixer },
6628 		.init_verbs = { alc260_favorit100_init_verbs },
6629 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6630 		.dac_nids = alc260_dac_nids,
6631 		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6632 		.adc_nids = alc260_dual_adc_nids,
6633 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6634 		.channel_mode = alc260_modes,
6635 		.num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6636 		.input_mux = alc260_favorit100_capture_sources,
6637 	},
6638 	[ALC260_WILL] = {
6639 		.mixers = { alc260_will_mixer },
6640 		.init_verbs = { alc260_init_verbs, alc260_will_verbs },
6641 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6642 		.dac_nids = alc260_dac_nids,
6643 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6644 		.adc_nids = alc260_adc_nids,
6645 		.dig_out_nid = ALC260_DIGOUT_NID,
6646 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6647 		.channel_mode = alc260_modes,
6648 		.input_mux = &alc260_capture_source,
6649 	},
6650 	[ALC260_REPLACER_672V] = {
6651 		.mixers = { alc260_replacer_672v_mixer },
6652 		.init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6653 		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
6654 		.dac_nids = alc260_dac_nids,
6655 		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6656 		.adc_nids = alc260_adc_nids,
6657 		.dig_out_nid = ALC260_DIGOUT_NID,
6658 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6659 		.channel_mode = alc260_modes,
6660 		.input_mux = &alc260_capture_source,
6661 		.unsol_event = alc260_replacer_672v_unsol_event,
6662 		.init_hook = alc260_replacer_672v_automute,
6663 	},
6664 #ifdef CONFIG_SND_DEBUG
6665 	[ALC260_TEST] = {
6666 		.mixers = { alc260_test_mixer },
6667 		.init_verbs = { alc260_test_init_verbs },
6668 		.num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6669 		.dac_nids = alc260_test_dac_nids,
6670 		.num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6671 		.adc_nids = alc260_test_adc_nids,
6672 		.num_channel_mode = ARRAY_SIZE(alc260_modes),
6673 		.channel_mode = alc260_modes,
6674 		.num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6675 		.input_mux = alc260_test_capture_sources,
6676 	},
6677 #endif
6678 };
6679 
6680 static int patch_alc260(struct hda_codec *codec)
6681 {
6682 	struct alc_spec *spec;
6683 	int err, board_config;
6684 
6685 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6686 	if (spec == NULL)
6687 		return -ENOMEM;
6688 
6689 	codec->spec = spec;
6690 
6691 	board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6692 						  alc260_models,
6693 						  alc260_cfg_tbl);
6694 	if (board_config < 0) {
6695 		snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6696 			   codec->chip_name);
6697 		board_config = ALC260_AUTO;
6698 	}
6699 
6700 	if (board_config == ALC260_AUTO) {
6701 		/* automatic parse from the BIOS config */
6702 		err = alc260_parse_auto_config(codec);
6703 		if (err < 0) {
6704 			alc_free(codec);
6705 			return err;
6706 		} else if (!err) {
6707 			printk(KERN_INFO
6708 			       "hda_codec: Cannot set up configuration "
6709 			       "from BIOS.  Using base mode...\n");
6710 			board_config = ALC260_BASIC;
6711 		}
6712 	}
6713 
6714 	err = snd_hda_attach_beep_device(codec, 0x1);
6715 	if (err < 0) {
6716 		alc_free(codec);
6717 		return err;
6718 	}
6719 
6720 	if (board_config != ALC260_AUTO)
6721 		setup_preset(codec, &alc260_presets[board_config]);
6722 
6723 	spec->stream_analog_playback = &alc260_pcm_analog_playback;
6724 	spec->stream_analog_capture = &alc260_pcm_analog_capture;
6725 
6726 	spec->stream_digital_playback = &alc260_pcm_digital_playback;
6727 	spec->stream_digital_capture = &alc260_pcm_digital_capture;
6728 
6729 	if (!spec->adc_nids && spec->input_mux) {
6730 		/* check whether NID 0x04 is valid */
6731 		unsigned int wcap = get_wcaps(codec, 0x04);
6732 		wcap = get_wcaps_type(wcap);
6733 		/* get type */
6734 		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6735 			spec->adc_nids = alc260_adc_nids_alt;
6736 			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6737 		} else {
6738 			spec->adc_nids = alc260_adc_nids;
6739 			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6740 		}
6741 	}
6742 	set_capture_mixer(codec);
6743 	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6744 
6745 	spec->vmaster_nid = 0x08;
6746 
6747 	codec->patch_ops = alc_patch_ops;
6748 	if (board_config == ALC260_AUTO)
6749 		spec->init_hook = alc260_auto_init;
6750 #ifdef CONFIG_SND_HDA_POWER_SAVE
6751 	if (!spec->loopback.amplist)
6752 		spec->loopback.amplist = alc260_loopbacks;
6753 #endif
6754 
6755 	return 0;
6756 }
6757 
6758 
6759 /*
6760  * ALC882/883/885/888/889 support
6761  *
6762  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6763  * configuration.  Each pin widget can choose any input DACs and a mixer.
6764  * Each ADC is connected from a mixer of all inputs.  This makes possible
6765  * 6-channel independent captures.
6766  *
6767  * In addition, an independent DAC for the multi-playback (not used in this
6768  * driver yet).
6769  */
6770 #define ALC882_DIGOUT_NID	0x06
6771 #define ALC882_DIGIN_NID	0x0a
6772 #define ALC883_DIGOUT_NID	ALC882_DIGOUT_NID
6773 #define ALC883_DIGIN_NID	ALC882_DIGIN_NID
6774 #define ALC1200_DIGOUT_NID	0x10
6775 
6776 
6777 static struct hda_channel_mode alc882_ch_modes[1] = {
6778 	{ 8, NULL }
6779 };
6780 
6781 /* DACs */
6782 static hda_nid_t alc882_dac_nids[4] = {
6783 	/* front, rear, clfe, rear_surr */
6784 	0x02, 0x03, 0x04, 0x05
6785 };
6786 #define alc883_dac_nids		alc882_dac_nids
6787 
6788 /* ADCs */
6789 #define alc882_adc_nids		alc880_adc_nids
6790 #define alc882_adc_nids_alt	alc880_adc_nids_alt
6791 #define alc883_adc_nids		alc882_adc_nids_alt
6792 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6793 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6794 #define alc889_adc_nids		alc880_adc_nids
6795 
6796 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6797 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6798 #define alc883_capsrc_nids	alc882_capsrc_nids_alt
6799 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6800 #define alc889_capsrc_nids	alc882_capsrc_nids
6801 
6802 /* input MUX */
6803 /* FIXME: should be a matrix-type input source selection */
6804 
6805 static struct hda_input_mux alc882_capture_source = {
6806 	.num_items = 4,
6807 	.items = {
6808 		{ "Mic", 0x0 },
6809 		{ "Front Mic", 0x1 },
6810 		{ "Line", 0x2 },
6811 		{ "CD", 0x4 },
6812 	},
6813 };
6814 
6815 #define alc883_capture_source	alc882_capture_source
6816 
6817 static struct hda_input_mux alc889_capture_source = {
6818 	.num_items = 3,
6819 	.items = {
6820 		{ "Front Mic", 0x0 },
6821 		{ "Mic", 0x3 },
6822 		{ "Line", 0x2 },
6823 	},
6824 };
6825 
6826 static struct hda_input_mux mb5_capture_source = {
6827 	.num_items = 3,
6828 	.items = {
6829 		{ "Mic", 0x1 },
6830 		{ "Line", 0x2 },
6831 		{ "CD", 0x4 },
6832 	},
6833 };
6834 
6835 static struct hda_input_mux macmini3_capture_source = {
6836 	.num_items = 2,
6837 	.items = {
6838 		{ "Line", 0x2 },
6839 		{ "CD", 0x4 },
6840 	},
6841 };
6842 
6843 static struct hda_input_mux alc883_3stack_6ch_intel = {
6844 	.num_items = 4,
6845 	.items = {
6846 		{ "Mic", 0x1 },
6847 		{ "Front Mic", 0x0 },
6848 		{ "Line", 0x2 },
6849 		{ "CD", 0x4 },
6850 	},
6851 };
6852 
6853 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6854 	.num_items = 2,
6855 	.items = {
6856 		{ "Mic", 0x1 },
6857 		{ "Line", 0x2 },
6858 	},
6859 };
6860 
6861 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6862 	.num_items = 4,
6863 	.items = {
6864 		{ "Mic", 0x0 },
6865 		{ "iMic", 0x1 },
6866 		{ "Line", 0x2 },
6867 		{ "CD", 0x4 },
6868 	},
6869 };
6870 
6871 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6872 	.num_items = 2,
6873 	.items = {
6874 		{ "Mic", 0x0 },
6875 		{ "Int Mic", 0x1 },
6876 	},
6877 };
6878 
6879 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6880 	.num_items = 3,
6881 	.items = {
6882 		{ "Mic", 0x0 },
6883 		{ "Front Mic", 0x1 },
6884 		{ "Line", 0x4 },
6885 	},
6886 };
6887 
6888 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6889 	.num_items = 2,
6890 	.items = {
6891 		{ "Mic", 0x0 },
6892 		{ "Line", 0x2 },
6893 	},
6894 };
6895 
6896 static struct hda_input_mux alc889A_mb31_capture_source = {
6897 	.num_items = 2,
6898 	.items = {
6899 		{ "Mic", 0x0 },
6900 		/* Front Mic (0x01) unused */
6901 		{ "Line", 0x2 },
6902 		/* Line 2 (0x03) unused */
6903 		/* CD (0x04) unused? */
6904 	},
6905 };
6906 
6907 /*
6908  * 2ch mode
6909  */
6910 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6911 	{ 2, NULL }
6912 };
6913 
6914 /*
6915  * 2ch mode
6916  */
6917 static struct hda_verb alc882_3ST_ch2_init[] = {
6918 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6919 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6920 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6921 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6922 	{ } /* end */
6923 };
6924 
6925 /*
6926  * 4ch mode
6927  */
6928 static struct hda_verb alc882_3ST_ch4_init[] = {
6929 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6930 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6931 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6932 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6933 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6934 	{ } /* end */
6935 };
6936 
6937 /*
6938  * 6ch mode
6939  */
6940 static struct hda_verb alc882_3ST_ch6_init[] = {
6941 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6942 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6943 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6944 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6945 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6946 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6947 	{ } /* end */
6948 };
6949 
6950 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6951 	{ 2, alc882_3ST_ch2_init },
6952 	{ 4, alc882_3ST_ch4_init },
6953 	{ 6, alc882_3ST_ch6_init },
6954 };
6955 
6956 #define alc883_3ST_6ch_modes	alc882_3ST_6ch_modes
6957 
6958 /*
6959  * 2ch mode
6960  */
6961 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6962 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6963 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6964 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6965 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6966 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6967 	{ } /* end */
6968 };
6969 
6970 /*
6971  * 4ch mode
6972  */
6973 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6974 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6975 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6976 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6977 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6978 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6979 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6980 	{ } /* end */
6981 };
6982 
6983 /*
6984  * 6ch mode
6985  */
6986 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6987 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6988 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6989 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6990 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6991 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6992 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6993 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6994 	{ } /* end */
6995 };
6996 
6997 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6998 	{ 2, alc883_3ST_ch2_clevo_init },
6999 	{ 4, alc883_3ST_ch4_clevo_init },
7000 	{ 6, alc883_3ST_ch6_clevo_init },
7001 };
7002 
7003 
7004 /*
7005  * 6ch mode
7006  */
7007 static struct hda_verb alc882_sixstack_ch6_init[] = {
7008 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7009 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7010 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7011 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7012 	{ } /* end */
7013 };
7014 
7015 /*
7016  * 8ch mode
7017  */
7018 static struct hda_verb alc882_sixstack_ch8_init[] = {
7019 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7020 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7021 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7022 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7023 	{ } /* end */
7024 };
7025 
7026 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7027 	{ 6, alc882_sixstack_ch6_init },
7028 	{ 8, alc882_sixstack_ch8_init },
7029 };
7030 
7031 
7032 /* Macbook Air 2,1 */
7033 
7034 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7035       { 2, NULL },
7036 };
7037 
7038 /*
7039  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7040  */
7041 
7042 /*
7043  * 2ch mode
7044  */
7045 static struct hda_verb alc885_mbp_ch2_init[] = {
7046 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7047 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7048 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7049 	{ } /* end */
7050 };
7051 
7052 /*
7053  * 4ch mode
7054  */
7055 static struct hda_verb alc885_mbp_ch4_init[] = {
7056 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7057 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7058 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7059 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7060 	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7061 	{ } /* end */
7062 };
7063 
7064 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7065 	{ 2, alc885_mbp_ch2_init },
7066 	{ 4, alc885_mbp_ch4_init },
7067 };
7068 
7069 /*
7070  * 2ch
7071  * Speakers/Woofer/HP = Front
7072  * LineIn = Input
7073  */
7074 static struct hda_verb alc885_mb5_ch2_init[] = {
7075 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7076 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7077 	{ } /* end */
7078 };
7079 
7080 /*
7081  * 6ch mode
7082  * Speakers/HP = Front
7083  * Woofer = LFE
7084  * LineIn = Surround
7085  */
7086 static struct hda_verb alc885_mb5_ch6_init[] = {
7087 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7088 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7089 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7090 	{ } /* end */
7091 };
7092 
7093 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7094 	{ 2, alc885_mb5_ch2_init },
7095 	{ 6, alc885_mb5_ch6_init },
7096 };
7097 
7098 #define alc885_macmini3_6ch_modes	alc885_mb5_6ch_modes
7099 
7100 /*
7101  * 2ch mode
7102  */
7103 static struct hda_verb alc883_4ST_ch2_init[] = {
7104 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7105 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7106 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7107 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7108 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7109 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7110 	{ } /* end */
7111 };
7112 
7113 /*
7114  * 4ch mode
7115  */
7116 static struct hda_verb alc883_4ST_ch4_init[] = {
7117 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7118 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7119 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7120 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7121 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7122 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7123 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7124 	{ } /* end */
7125 };
7126 
7127 /*
7128  * 6ch mode
7129  */
7130 static struct hda_verb alc883_4ST_ch6_init[] = {
7131 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7132 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7133 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7134 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7135 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7136 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7137 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7138 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7139 	{ } /* end */
7140 };
7141 
7142 /*
7143  * 8ch mode
7144  */
7145 static struct hda_verb alc883_4ST_ch8_init[] = {
7146 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7147 	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7148 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7149 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7150 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7151 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7152 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7153 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7154 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7155 	{ } /* end */
7156 };
7157 
7158 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7159 	{ 2, alc883_4ST_ch2_init },
7160 	{ 4, alc883_4ST_ch4_init },
7161 	{ 6, alc883_4ST_ch6_init },
7162 	{ 8, alc883_4ST_ch8_init },
7163 };
7164 
7165 
7166 /*
7167  * 2ch mode
7168  */
7169 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7170 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7171 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7172 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7173 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7174 	{ } /* end */
7175 };
7176 
7177 /*
7178  * 4ch mode
7179  */
7180 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7181 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7182 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7183 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7184 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7185 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7186 	{ } /* end */
7187 };
7188 
7189 /*
7190  * 6ch mode
7191  */
7192 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7193 	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7194 	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7195 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7196 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7197 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7198 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7199 	{ } /* end */
7200 };
7201 
7202 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7203 	{ 2, alc883_3ST_ch2_intel_init },
7204 	{ 4, alc883_3ST_ch4_intel_init },
7205 	{ 6, alc883_3ST_ch6_intel_init },
7206 };
7207 
7208 /*
7209  * 2ch mode
7210  */
7211 static struct hda_verb alc889_ch2_intel_init[] = {
7212 	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7213 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7214 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7215 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7216 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7217 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7218 	{ } /* end */
7219 };
7220 
7221 /*
7222  * 6ch mode
7223  */
7224 static struct hda_verb alc889_ch6_intel_init[] = {
7225 	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7226 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7227 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7228 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7229 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7230 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7231 	{ } /* end */
7232 };
7233 
7234 /*
7235  * 8ch mode
7236  */
7237 static struct hda_verb alc889_ch8_intel_init[] = {
7238 	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7239 	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7240 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7241 	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7242 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7243 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7244 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7245 	{ } /* end */
7246 };
7247 
7248 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7249 	{ 2, alc889_ch2_intel_init },
7250 	{ 6, alc889_ch6_intel_init },
7251 	{ 8, alc889_ch8_intel_init },
7252 };
7253 
7254 /*
7255  * 6ch mode
7256  */
7257 static struct hda_verb alc883_sixstack_ch6_init[] = {
7258 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7259 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7260 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7261 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7262 	{ } /* end */
7263 };
7264 
7265 /*
7266  * 8ch mode
7267  */
7268 static struct hda_verb alc883_sixstack_ch8_init[] = {
7269 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7270 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7271 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7272 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7273 	{ } /* end */
7274 };
7275 
7276 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7277 	{ 6, alc883_sixstack_ch6_init },
7278 	{ 8, alc883_sixstack_ch8_init },
7279 };
7280 
7281 
7282 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7283  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7284  */
7285 static struct snd_kcontrol_new alc882_base_mixer[] = {
7286 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7287 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7288 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7289 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7290 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7291 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7292 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7293 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7294 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7295 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7296 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7297 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7298 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7299 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7300 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7301 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7302 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7303 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7304 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7305 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7306 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7307 	{ } /* end */
7308 };
7309 
7310 /* Macbook Air 2,1 same control for HP and internal Speaker */
7311 
7312 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7313       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7314       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7315      { }
7316 };
7317 
7318 
7319 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7320 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7321 	HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7322 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7323 	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7324 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7325 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7326 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7327 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7328 	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7329 	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7330 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7331 	{ } /* end */
7332 };
7333 
7334 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7335 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7336 	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7337 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7338 	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7339 	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7340 	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7341 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7342 	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7343 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7344 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7345 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7346 	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7347 	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7348 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7349 	{ } /* end */
7350 };
7351 
7352 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7353 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7354 	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7355 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7356 	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7357 	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7358 	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7359 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7360 	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7361 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7362 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7363 	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7364 	{ } /* end */
7365 };
7366 
7367 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7368 	HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7369 	HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7370 	HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7371 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7372 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7373 	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7374 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7375 	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7376 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7377 	{ } /* end */
7378 };
7379 
7380 
7381 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7382 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7383 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7384 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7385 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7386 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7387 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7388 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7389 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7390 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7391 	{ } /* end */
7392 };
7393 
7394 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7395 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7396 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7397 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7398 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7399 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7400 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7401 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7402 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7403 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7404 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7405 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7406 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7407 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7408 	{ } /* end */
7409 };
7410 
7411 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7412  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7413  */
7414 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7415 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7416 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7417 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7418 	HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7419 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7420 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7421 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7422 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7423 	HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7424 	HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7425 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7426 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7427 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7428 	{ } /* end */
7429 };
7430 
7431 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7432 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7433 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7434 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7435 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7436 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7437 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7438 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7439 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7440 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7441 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7442 	{ } /* end */
7443 };
7444 
7445 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7446 	{
7447 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7448 		.name = "Channel Mode",
7449 		.info = alc_ch_mode_info,
7450 		.get = alc_ch_mode_get,
7451 		.put = alc_ch_mode_put,
7452 	},
7453 	{ } /* end */
7454 };
7455 
7456 static struct hda_verb alc882_base_init_verbs[] = {
7457 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7458 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7459 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7460 	/* Rear mixer */
7461 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7462 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7463 	/* CLFE mixer */
7464 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7465 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7466 	/* Side mixer */
7467 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7468 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7469 
7470 	/* Front Pin: output 0 (0x0c) */
7471 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7472 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7473 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7474 	/* Rear Pin: output 1 (0x0d) */
7475 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7476 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7477 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7478 	/* CLFE Pin: output 2 (0x0e) */
7479 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7480 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7481 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7482 	/* Side Pin: output 3 (0x0f) */
7483 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7484 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7485 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7486 	/* Mic (rear) pin: input vref at 80% */
7487 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7488 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7489 	/* Front Mic pin: input vref at 80% */
7490 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7491 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7492 	/* Line In pin: input */
7493 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7494 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7495 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
7496 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7497 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7498 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7499 	/* CD pin widget for input */
7500 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7501 
7502 	/* FIXME: use matrix-type input source selection */
7503 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7504 	/* Input mixer2 */
7505 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7506 	/* Input mixer3 */
7507 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7508 	/* ADC2: mute amp left and right */
7509 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7510 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7511 	/* ADC3: mute amp left and right */
7512 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7513 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7514 
7515 	{ }
7516 };
7517 
7518 static struct hda_verb alc882_adc1_init_verbs[] = {
7519 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7520 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7521 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7522 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7523 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7524 	/* ADC1: mute amp left and right */
7525 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7526 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7527 	{ }
7528 };
7529 
7530 static struct hda_verb alc882_eapd_verbs[] = {
7531 	/* change to EAPD mode */
7532 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7533 	{0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7534 	{ }
7535 };
7536 
7537 static struct hda_verb alc889_eapd_verbs[] = {
7538 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7539 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7540 	{ }
7541 };
7542 
7543 static struct hda_verb alc_hp15_unsol_verbs[] = {
7544 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7545 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7546 	{}
7547 };
7548 
7549 static struct hda_verb alc885_init_verbs[] = {
7550 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7551 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7552 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7553 	/* Rear mixer */
7554 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7555 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7556 	/* CLFE mixer */
7557 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7558 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7559 	/* Side mixer */
7560 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7561 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7562 
7563 	/* Front HP Pin: output 0 (0x0c) */
7564 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7565 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7566 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7567 	/* Front Pin: output 0 (0x0c) */
7568 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7569 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7570 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7571 	/* Rear Pin: output 1 (0x0d) */
7572 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7573 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7574 	{0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7575 	/* CLFE Pin: output 2 (0x0e) */
7576 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7577 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7578 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7579 	/* Side Pin: output 3 (0x0f) */
7580 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7581 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7582 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7583 	/* Mic (rear) pin: input vref at 80% */
7584 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7585 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7586 	/* Front Mic pin: input vref at 80% */
7587 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7588 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7589 	/* Line In pin: input */
7590 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7591 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7592 
7593 	/* Mixer elements: 0x18, , 0x1a, 0x1b */
7594 	/* Input mixer1 */
7595 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7596 	/* Input mixer2 */
7597 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7598 	/* Input mixer3 */
7599 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7600 	/* ADC2: mute amp left and right */
7601 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7602 	/* ADC3: mute amp left and right */
7603 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7604 
7605 	{ }
7606 };
7607 
7608 static struct hda_verb alc885_init_input_verbs[] = {
7609 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7610 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7611 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7612 	{ }
7613 };
7614 
7615 
7616 /* Unmute Selector 24h and set the default input to front mic */
7617 static struct hda_verb alc889_init_input_verbs[] = {
7618 	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7619 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7620 	{ }
7621 };
7622 
7623 
7624 #define alc883_init_verbs	alc882_base_init_verbs
7625 
7626 /* Mac Pro test */
7627 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7628 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7629 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7630 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7631 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7632 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7633 	/* FIXME: this looks suspicious...
7634 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7635 	HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7636 	*/
7637 	{ } /* end */
7638 };
7639 
7640 static struct hda_verb alc882_macpro_init_verbs[] = {
7641 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7642 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7643 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7644 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7645 	/* Front Pin: output 0 (0x0c) */
7646 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7647 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7648 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7649 	/* Front Mic pin: input vref at 80% */
7650 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7651 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7652 	/* Speaker:  output */
7653 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7654 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7655 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7656 	/* Headphone output (output 0 - 0x0c) */
7657 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7658 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7659 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7660 
7661 	/* FIXME: use matrix-type input source selection */
7662 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7663 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7664 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7665 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7666 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7667 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7668 	/* Input mixer2 */
7669 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7670 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7671 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7672 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7673 	/* Input mixer3 */
7674 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7675 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7676 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7677 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7678 	/* ADC1: mute amp left and right */
7679 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7680 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7681 	/* ADC2: mute amp left and right */
7682 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7683 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7684 	/* ADC3: mute amp left and right */
7685 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7686 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7687 
7688 	{ }
7689 };
7690 
7691 /* Macbook 5,1 */
7692 static struct hda_verb alc885_mb5_init_verbs[] = {
7693 	/* DACs */
7694 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7695 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7696 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7697 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7698 	/* Front mixer */
7699 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7700 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7701 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7702 	/* Surround mixer */
7703 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7704 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7705 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7706 	/* LFE mixer */
7707 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7708 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7709 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7710 	/* HP mixer */
7711 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7712 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7713 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7714 	/* Front Pin (0x0c) */
7715 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7716 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7717 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7718 	/* LFE Pin (0x0e) */
7719 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7720 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7721 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7722 	/* HP Pin (0x0f) */
7723 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7724 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7725 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7726 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7727 	/* Front Mic pin: input vref at 80% */
7728 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7729 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7730 	/* Line In pin */
7731 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7732 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7733 
7734 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7735 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7736 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7737 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7738 	{ }
7739 };
7740 
7741 /* Macmini 3,1 */
7742 static struct hda_verb alc885_macmini3_init_verbs[] = {
7743 	/* DACs */
7744 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7745 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7746 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7747 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7748 	/* Front mixer */
7749 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7750 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7751 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7752 	/* Surround mixer */
7753 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7754 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7755 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7756 	/* LFE mixer */
7757 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7758 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7759 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7760 	/* HP mixer */
7761 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7762 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7763 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7764 	/* Front Pin (0x0c) */
7765 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7766 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7767 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7768 	/* LFE Pin (0x0e) */
7769 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7770 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7771 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7772 	/* HP Pin (0x0f) */
7773 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7774 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7775 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7776 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7777 	/* Line In pin */
7778 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7779 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7780 
7781 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7782 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7783 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7784 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7785 	{ }
7786 };
7787 
7788 
7789 static struct hda_verb alc885_mba21_init_verbs[] = {
7790 	/*Internal and HP Speaker Mixer*/
7791 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7792 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7793 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7794 	/*Internal Speaker Pin (0x0c)*/
7795 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
7796 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7797 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7798 	/* HP Pin: output 0 (0x0e) */
7799 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7800 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7801 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7802 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
7803 	/* Line in (is hp when jack connected)*/
7804 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
7805 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7806 
7807 	{ }
7808  };
7809 
7810 
7811 /* Macbook Pro rev3 */
7812 static struct hda_verb alc885_mbp3_init_verbs[] = {
7813 	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7814 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7815 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7816 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7817 	/* Rear mixer */
7818 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7819 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7820 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7821 	/* HP mixer */
7822 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7823 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7824 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7825 	/* Front Pin: output 0 (0x0c) */
7826 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7827 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7828 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7829 	/* HP Pin: output 0 (0x0e) */
7830 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7831 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7832 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7833 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7834 	/* Mic (rear) pin: input vref at 80% */
7835 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7836 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7837 	/* Front Mic pin: input vref at 80% */
7838 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7839 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7840 	/* Line In pin: use output 1 when in LineOut mode */
7841 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7842 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7843 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7844 
7845 	/* FIXME: use matrix-type input source selection */
7846 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7847 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7848 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7849 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7850 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7851 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7852 	/* Input mixer2 */
7853 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7854 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7855 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7856 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7857 	/* Input mixer3 */
7858 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7859 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7860 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7861 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7862 	/* ADC1: mute amp left and right */
7863 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7864 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7865 	/* ADC2: mute amp left and right */
7866 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7867 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7868 	/* ADC3: mute amp left and right */
7869 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7870 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7871 
7872 	{ }
7873 };
7874 
7875 /* iMac 9,1 */
7876 static struct hda_verb alc885_imac91_init_verbs[] = {
7877 	/* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7878 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7879 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7880 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7881 	/* Rear mixer */
7882 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7883 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7884 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7885 	/* HP Pin: output 0 (0x0c) */
7886 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7887 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7888 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7889 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7890 	/* Internal Speakers: output 0 (0x0d) */
7891 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7892 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7893 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7894 	/* Mic (rear) pin: input vref at 80% */
7895 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7896 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7897 	/* Front Mic pin: input vref at 80% */
7898 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7899 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7900 	/* Line In pin: use output 1 when in LineOut mode */
7901 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7902 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7903 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7904 
7905 	/* FIXME: use matrix-type input source selection */
7906 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7907 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7908 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7909 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7910 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7911 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7912 	/* Input mixer2 */
7913 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7914 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7915 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7916 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7917 	/* Input mixer3 */
7918 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7919 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7920 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7921 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7922 	/* ADC1: mute amp left and right */
7923 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7924 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7925 	/* ADC2: mute amp left and right */
7926 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7927 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7928 	/* ADC3: mute amp left and right */
7929 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7930 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7931 
7932 	{ }
7933 };
7934 
7935 /* iMac 24 mixer. */
7936 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7937 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7938 	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7939 	{ } /* end */
7940 };
7941 
7942 /* iMac 24 init verbs. */
7943 static struct hda_verb alc885_imac24_init_verbs[] = {
7944 	/* Internal speakers: output 0 (0x0c) */
7945 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7946 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7947 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7948 	/* Internal speakers: output 0 (0x0c) */
7949 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7950 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7951 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7952 	/* Headphone: output 0 (0x0c) */
7953 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7954 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7955 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7956 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7957 	/* Front Mic: input vref at 80% */
7958 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7959 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7960 	{ }
7961 };
7962 
7963 /* Toggle speaker-output according to the hp-jack state */
7964 static void alc885_imac24_setup(struct hda_codec *codec)
7965 {
7966 	struct alc_spec *spec = codec->spec;
7967 
7968 	spec->autocfg.hp_pins[0] = 0x14;
7969 	spec->autocfg.speaker_pins[0] = 0x18;
7970 	spec->autocfg.speaker_pins[1] = 0x1a;
7971 }
7972 
7973 #define alc885_mb5_setup	alc885_imac24_setup
7974 #define alc885_macmini3_setup	alc885_imac24_setup
7975 
7976 /* Macbook Air 2,1 */
7977 static void alc885_mba21_setup(struct hda_codec *codec)
7978 {
7979        struct alc_spec *spec = codec->spec;
7980 
7981        spec->autocfg.hp_pins[0] = 0x14;
7982        spec->autocfg.speaker_pins[0] = 0x18;
7983 }
7984 
7985 
7986 
7987 static void alc885_mbp3_setup(struct hda_codec *codec)
7988 {
7989 	struct alc_spec *spec = codec->spec;
7990 
7991 	spec->autocfg.hp_pins[0] = 0x15;
7992 	spec->autocfg.speaker_pins[0] = 0x14;
7993 }
7994 
7995 static void alc885_imac91_setup(struct hda_codec *codec)
7996 {
7997 	struct alc_spec *spec = codec->spec;
7998 
7999 	spec->autocfg.hp_pins[0] = 0x14;
8000 	spec->autocfg.speaker_pins[0] = 0x15;
8001 	spec->autocfg.speaker_pins[1] = 0x1a;
8002 }
8003 
8004 static struct hda_verb alc882_targa_verbs[] = {
8005 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8006 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8007 
8008 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8009 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8010 
8011 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8012 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8013 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8014 
8015 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8016 	{ } /* end */
8017 };
8018 
8019 /* toggle speaker-output according to the hp-jack state */
8020 static void alc882_targa_automute(struct hda_codec *codec)
8021 {
8022 	struct alc_spec *spec = codec->spec;
8023 	alc_automute_amp(codec);
8024 	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8025 				  spec->jack_present ? 1 : 3);
8026 }
8027 
8028 static void alc882_targa_setup(struct hda_codec *codec)
8029 {
8030 	struct alc_spec *spec = codec->spec;
8031 
8032 	spec->autocfg.hp_pins[0] = 0x14;
8033 	spec->autocfg.speaker_pins[0] = 0x1b;
8034 }
8035 
8036 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8037 {
8038 	if ((res >> 26) == ALC880_HP_EVENT)
8039 		alc882_targa_automute(codec);
8040 }
8041 
8042 static struct hda_verb alc882_asus_a7j_verbs[] = {
8043 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8044 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8045 
8046 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8047 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8048 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8049 
8050 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8051 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8052 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8053 
8054 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8055 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8056 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8057 	{ } /* end */
8058 };
8059 
8060 static struct hda_verb alc882_asus_a7m_verbs[] = {
8061 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8062 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8063 
8064 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8065 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8066 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8067 
8068 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8069 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8070 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8071 
8072 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8073 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8074 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8075  	{ } /* end */
8076 };
8077 
8078 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8079 {
8080 	unsigned int gpiostate, gpiomask, gpiodir;
8081 
8082 	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8083 				       AC_VERB_GET_GPIO_DATA, 0);
8084 
8085 	if (!muted)
8086 		gpiostate |= (1 << pin);
8087 	else
8088 		gpiostate &= ~(1 << pin);
8089 
8090 	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8091 				      AC_VERB_GET_GPIO_MASK, 0);
8092 	gpiomask |= (1 << pin);
8093 
8094 	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8095 				     AC_VERB_GET_GPIO_DIRECTION, 0);
8096 	gpiodir |= (1 << pin);
8097 
8098 
8099 	snd_hda_codec_write(codec, codec->afg, 0,
8100 			    AC_VERB_SET_GPIO_MASK, gpiomask);
8101 	snd_hda_codec_write(codec, codec->afg, 0,
8102 			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8103 
8104 	msleep(1);
8105 
8106 	snd_hda_codec_write(codec, codec->afg, 0,
8107 			    AC_VERB_SET_GPIO_DATA, gpiostate);
8108 }
8109 
8110 /* set up GPIO at initialization */
8111 static void alc885_macpro_init_hook(struct hda_codec *codec)
8112 {
8113 	alc882_gpio_mute(codec, 0, 0);
8114 	alc882_gpio_mute(codec, 1, 0);
8115 }
8116 
8117 /* set up GPIO and update auto-muting at initialization */
8118 static void alc885_imac24_init_hook(struct hda_codec *codec)
8119 {
8120 	alc885_macpro_init_hook(codec);
8121 	alc_automute_amp(codec);
8122 }
8123 
8124 /*
8125  * generic initialization of ADC, input mixers and output mixers
8126  */
8127 static struct hda_verb alc883_auto_init_verbs[] = {
8128 	/*
8129 	 * Unmute ADC0-2 and set the default input to mic-in
8130 	 */
8131 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8132 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8133 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8134 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8135 
8136 	/*
8137 	 * Set up output mixers (0x0c - 0x0f)
8138 	 */
8139 	/* set vol=0 to output mixers */
8140 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8141 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8142 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8143 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8144 	/* set up input amps for analog loopback */
8145 	/* Amp Indices: DAC = 0, mixer = 1 */
8146 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8147 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8148 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8149 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8150 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8151 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8152 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8153 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8154 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8155 	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8156 
8157 	/* FIXME: use matrix-type input source selection */
8158 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8159 	/* Input mixer2 */
8160 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8161 	/* Input mixer3 */
8162 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8163 	{ }
8164 };
8165 
8166 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8167 static struct hda_verb alc889A_mb31_ch2_init[] = {
8168 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8169 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8170 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8171 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8172 	{ } /* end */
8173 };
8174 
8175 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8176 static struct hda_verb alc889A_mb31_ch4_init[] = {
8177 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8178 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8179 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8180 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8181 	{ } /* end */
8182 };
8183 
8184 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8185 static struct hda_verb alc889A_mb31_ch5_init[] = {
8186 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8187 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8188 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8189 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8190 	{ } /* end */
8191 };
8192 
8193 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8194 static struct hda_verb alc889A_mb31_ch6_init[] = {
8195 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8196 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8197 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8198 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8199 	{ } /* end */
8200 };
8201 
8202 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8203 	{ 2, alc889A_mb31_ch2_init },
8204 	{ 4, alc889A_mb31_ch4_init },
8205 	{ 5, alc889A_mb31_ch5_init },
8206 	{ 6, alc889A_mb31_ch6_init },
8207 };
8208 
8209 static struct hda_verb alc883_medion_eapd_verbs[] = {
8210         /* eanable EAPD on medion laptop */
8211 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8212 	{0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8213 	{ }
8214 };
8215 
8216 #define alc883_base_mixer	alc882_base_mixer
8217 
8218 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8219 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8220 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8221 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8222 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8223 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8224 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8225 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8226 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8227 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8228 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8229 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8230 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8231 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8232 	{ } /* end */
8233 };
8234 
8235 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8236 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8237 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8238 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8239 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8240 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8241 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8242 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8243 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8244 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8245 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8246 	{ } /* end */
8247 };
8248 
8249 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8250 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8251 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8252 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8253 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8254 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8255 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8256 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8257 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8258 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8259 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8260 	{ } /* end */
8261 };
8262 
8263 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8264 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8265 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8266 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8267 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8268 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8269 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8270 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8271 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8272 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8273 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8274 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8275 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8276 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8277 	{ } /* end */
8278 };
8279 
8280 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8281 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8282 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8283 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8284 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8285 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8286 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8287 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8288 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8289 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8290 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8291 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8292 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8293 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8294 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8295 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8296 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8297 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8298 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8299 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8300 	{ } /* end */
8301 };
8302 
8303 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8304 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8305 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8306 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8307 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8308 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8309 			      HDA_OUTPUT),
8310 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8311 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8312 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8313 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8314 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8315 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8316 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8317 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8318 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8319 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8320 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8321 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8322 	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8323 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8324 	{ } /* end */
8325 };
8326 
8327 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8328 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8329 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8330 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8331 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8332 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8333 			      HDA_OUTPUT),
8334 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8335 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8336 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8337 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8338 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8339 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8340 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8341 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8342 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8343 	HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8344 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8345 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8346 	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8347 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8348 	{ } /* end */
8349 };
8350 
8351 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8352 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8353 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8354 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8355 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8356 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8357 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8358 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8359 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8360 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8361 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8362 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8363 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8364 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8365 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8366 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8367 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8368 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8369 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8370 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8371 	{ } /* end */
8372 };
8373 
8374 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8375 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8376 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8377 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8378 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8379 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8380 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8381 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8382 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8383 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8384 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8385 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8386 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8387 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8388 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8389 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8390 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8391 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8392 	{ } /* end */
8393 };
8394 
8395 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8396 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8397 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8398 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8399 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8400 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8401 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8402 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8403 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8404 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8405 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8406 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8407 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8408 	{ } /* end */
8409 };
8410 
8411 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8412 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8413 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8414 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8415 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8416 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8417 	{ } /* end */
8418 };
8419 
8420 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8421 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8422 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8423 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8424 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8425 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8426 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8427 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8428 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8429 	{ } /* end */
8430 };
8431 
8432 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8433 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8434 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8435 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8436 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8437 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8438 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8439 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8440 	HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8441 	HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8442 	{ } /* end */
8443 };
8444 
8445 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8446 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8447 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8448 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8449 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8450 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8451 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8452 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8453 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8454 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8455 	{ } /* end */
8456 };
8457 
8458 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8459 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8460 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8461 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8462 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8463 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8464 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8465 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8466 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8467 	{ } /* end */
8468 };
8469 
8470 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8471 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8472 	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8473 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8474 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8475 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8476 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8477 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8478 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8479 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8480 	{ } /* end */
8481 };
8482 
8483 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8484 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8485 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8486 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8487 	HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8488 	HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8489 						0x0d, 1, 0x0, HDA_OUTPUT),
8490 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8491 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8492 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8493 	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8494 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8495 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8496 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8497 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8498 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8499 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8500 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8501 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8502 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8503 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8504 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8505 	{ } /* end */
8506 };
8507 
8508 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8509 	/* Output mixers */
8510 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8511 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8512 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8513 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8514 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8515 		HDA_OUTPUT),
8516 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8517 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8518 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8519 	/* Output switches */
8520 	HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8521 	HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8522 	HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8523 	/* Boost mixers */
8524 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8525 	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8526 	/* Input mixers */
8527 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8528 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8529 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8530 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8531 	{ } /* end */
8532 };
8533 
8534 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8535 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8536 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8537 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8538 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8539 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8540 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8541 	{ } /* end */
8542 };
8543 
8544 static struct hda_bind_ctls alc883_bind_cap_vol = {
8545 	.ops = &snd_hda_bind_vol,
8546 	.values = {
8547 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8548 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8549 		0
8550 	},
8551 };
8552 
8553 static struct hda_bind_ctls alc883_bind_cap_switch = {
8554 	.ops = &snd_hda_bind_sw,
8555 	.values = {
8556 		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8557 		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8558 		0
8559 	},
8560 };
8561 
8562 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8563 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8564 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8565 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8566 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8567 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8568 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8569 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8570 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8571 	{ } /* end */
8572 };
8573 
8574 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8575 	HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8576 	HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8577 	{
8578 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8579 		/* .name = "Capture Source", */
8580 		.name = "Input Source",
8581 		.count = 1,
8582 		.info = alc_mux_enum_info,
8583 		.get = alc_mux_enum_get,
8584 		.put = alc_mux_enum_put,
8585 	},
8586 	{ } /* end */
8587 };
8588 
8589 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8590 	{
8591 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8592 		.name = "Channel Mode",
8593 		.info = alc_ch_mode_info,
8594 		.get = alc_ch_mode_get,
8595 		.put = alc_ch_mode_put,
8596 	},
8597 	{ } /* end */
8598 };
8599 
8600 /* toggle speaker-output according to the hp-jack state */
8601 static void alc883_mitac_setup(struct hda_codec *codec)
8602 {
8603 	struct alc_spec *spec = codec->spec;
8604 
8605 	spec->autocfg.hp_pins[0] = 0x15;
8606 	spec->autocfg.speaker_pins[0] = 0x14;
8607 	spec->autocfg.speaker_pins[1] = 0x17;
8608 }
8609 
8610 /* auto-toggle front mic */
8611 /*
8612 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8613 {
8614 	unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8615 
8616 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8617 }
8618 */
8619 
8620 static struct hda_verb alc883_mitac_verbs[] = {
8621 	/* HP */
8622 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8623 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8624 	/* Subwoofer */
8625 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8626 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8627 
8628 	/* enable unsolicited event */
8629 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8630 	/* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8631 
8632 	{ } /* end */
8633 };
8634 
8635 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8636 	/* HP */
8637 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8638 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8639 	/* Int speaker */
8640 	/*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8641 
8642 	/* enable unsolicited event */
8643 	/*
8644 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8645 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8646 	*/
8647 
8648 	{ } /* end */
8649 };
8650 
8651 static struct hda_verb alc883_clevo_m720_verbs[] = {
8652 	/* HP */
8653 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8654 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8655 	/* Int speaker */
8656 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8657 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8658 
8659 	/* enable unsolicited event */
8660 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8661 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8662 
8663 	{ } /* end */
8664 };
8665 
8666 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8667 	/* HP */
8668 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8669 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8670 	/* Subwoofer */
8671 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8672 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8673 
8674 	/* enable unsolicited event */
8675 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8676 
8677 	{ } /* end */
8678 };
8679 
8680 static struct hda_verb alc883_targa_verbs[] = {
8681 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8682 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8683 
8684 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8685 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8686 
8687 /* Connect Line-Out side jack (SPDIF) to Side */
8688 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8689 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8690 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8691 /* Connect Mic jack to CLFE */
8692 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8693 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8694 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8695 /* Connect Line-in jack to Surround */
8696 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8697 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8698 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8699 /* Connect HP out jack to Front */
8700 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8701 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8702 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8703 
8704 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8705 
8706 	{ } /* end */
8707 };
8708 
8709 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8710 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8711 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8712         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8713 	{ } /* end */
8714 };
8715 
8716 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8717         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8718 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8719         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8720         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8721 	{ } /* end */
8722 };
8723 
8724 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8725 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8726 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8727 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8728 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8729 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8730 	{ } /* end */
8731 };
8732 
8733 static struct hda_verb alc883_haier_w66_verbs[] = {
8734 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8735 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8736 
8737 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8738 
8739 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8740 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8741 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8742 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8743 	{ } /* end */
8744 };
8745 
8746 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8747 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8748 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8749 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8750 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8751 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8752 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8753 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8754 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8755 	{ } /* end */
8756 };
8757 
8758 static struct hda_verb alc888_6st_dell_verbs[] = {
8759 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8760 	{ }
8761 };
8762 
8763 static struct hda_verb alc883_vaiott_verbs[] = {
8764 	/* HP */
8765 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8766 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8767 
8768 	/* enable unsolicited event */
8769 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8770 
8771 	{ } /* end */
8772 };
8773 
8774 static void alc888_3st_hp_setup(struct hda_codec *codec)
8775 {
8776 	struct alc_spec *spec = codec->spec;
8777 
8778 	spec->autocfg.hp_pins[0] = 0x1b;
8779 	spec->autocfg.speaker_pins[0] = 0x14;
8780 	spec->autocfg.speaker_pins[1] = 0x16;
8781 	spec->autocfg.speaker_pins[2] = 0x18;
8782 }
8783 
8784 static struct hda_verb alc888_3st_hp_verbs[] = {
8785 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Front: output 0 (0x0c) */
8786 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Rear : output 1 (0x0d) */
8787 	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},	/* CLFE : output 2 (0x0e) */
8788 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8789 	{ } /* end */
8790 };
8791 
8792 /*
8793  * 2ch mode
8794  */
8795 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8796 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8797 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8798 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8799 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8800 	{ } /* end */
8801 };
8802 
8803 /*
8804  * 4ch mode
8805  */
8806 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8807 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8808 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8809 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8810 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8811 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8812 	{ } /* end */
8813 };
8814 
8815 /*
8816  * 6ch mode
8817  */
8818 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8819 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8820 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8821 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8822 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8823 	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8824 	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8825 	{ } /* end */
8826 };
8827 
8828 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8829 	{ 2, alc888_3st_hp_2ch_init },
8830 	{ 4, alc888_3st_hp_4ch_init },
8831 	{ 6, alc888_3st_hp_6ch_init },
8832 };
8833 
8834 /* toggle front-jack and RCA according to the hp-jack state */
8835 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8836 {
8837  	unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8838 
8839 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8840 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8841 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8842 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8843 }
8844 
8845 /* toggle RCA according to the front-jack state */
8846 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8847 {
8848  	unsigned int present = snd_hda_jack_detect(codec, 0x14);
8849 
8850 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8851 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8852 }
8853 
8854 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8855 					     unsigned int res)
8856 {
8857 	if ((res >> 26) == ALC880_HP_EVENT)
8858 		alc888_lenovo_ms7195_front_automute(codec);
8859 	if ((res >> 26) == ALC880_FRONT_EVENT)
8860 		alc888_lenovo_ms7195_rca_automute(codec);
8861 }
8862 
8863 static struct hda_verb alc883_medion_md2_verbs[] = {
8864 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8865 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8866 
8867 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8868 
8869 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8870 	{ } /* end */
8871 };
8872 
8873 /* toggle speaker-output according to the hp-jack state */
8874 static void alc883_medion_md2_setup(struct hda_codec *codec)
8875 {
8876 	struct alc_spec *spec = codec->spec;
8877 
8878 	spec->autocfg.hp_pins[0] = 0x14;
8879 	spec->autocfg.speaker_pins[0] = 0x15;
8880 }
8881 
8882 /* toggle speaker-output according to the hp-jack state */
8883 #define alc883_targa_init_hook		alc882_targa_init_hook
8884 #define alc883_targa_unsol_event	alc882_targa_unsol_event
8885 
8886 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8887 {
8888 	unsigned int present;
8889 
8890 	present = snd_hda_jack_detect(codec, 0x18);
8891 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8892 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8893 }
8894 
8895 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8896 {
8897 	struct alc_spec *spec = codec->spec;
8898 
8899 	spec->autocfg.hp_pins[0] = 0x15;
8900 	spec->autocfg.speaker_pins[0] = 0x14;
8901 }
8902 
8903 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8904 {
8905 	alc_automute_amp(codec);
8906 	alc883_clevo_m720_mic_automute(codec);
8907 }
8908 
8909 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8910 					   unsigned int res)
8911 {
8912 	switch (res >> 26) {
8913 	case ALC880_MIC_EVENT:
8914 		alc883_clevo_m720_mic_automute(codec);
8915 		break;
8916 	default:
8917 		alc_automute_amp_unsol_event(codec, res);
8918 		break;
8919 	}
8920 }
8921 
8922 /* toggle speaker-output according to the hp-jack state */
8923 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8924 {
8925 	struct alc_spec *spec = codec->spec;
8926 
8927 	spec->autocfg.hp_pins[0] = 0x14;
8928 	spec->autocfg.speaker_pins[0] = 0x15;
8929 }
8930 
8931 static void alc883_haier_w66_setup(struct hda_codec *codec)
8932 {
8933 	struct alc_spec *spec = codec->spec;
8934 
8935 	spec->autocfg.hp_pins[0] = 0x1b;
8936 	spec->autocfg.speaker_pins[0] = 0x14;
8937 }
8938 
8939 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8940 {
8941 	int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8942 
8943 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8944 				 HDA_AMP_MUTE, bits);
8945 }
8946 
8947 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8948 {
8949 	int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8950 
8951 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8952 				 HDA_AMP_MUTE, bits);
8953 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8954 				 HDA_AMP_MUTE, bits);
8955 }
8956 
8957 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8958 					   unsigned int res)
8959 {
8960 	if ((res >> 26) == ALC880_HP_EVENT)
8961 		alc883_lenovo_101e_all_automute(codec);
8962 	if ((res >> 26) == ALC880_FRONT_EVENT)
8963 		alc883_lenovo_101e_ispeaker_automute(codec);
8964 }
8965 
8966 /* toggle speaker-output according to the hp-jack state */
8967 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8968 {
8969 	struct alc_spec *spec = codec->spec;
8970 
8971 	spec->autocfg.hp_pins[0] = 0x14;
8972 	spec->autocfg.speaker_pins[0] = 0x15;
8973 	spec->autocfg.speaker_pins[1] = 0x16;
8974 }
8975 
8976 static struct hda_verb alc883_acer_eapd_verbs[] = {
8977 	/* HP Pin: output 0 (0x0c) */
8978 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8979 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8980 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8981 	/* Front Pin: output 0 (0x0c) */
8982 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8983 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8984 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8985 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8986         /* eanable EAPD on medion laptop */
8987 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8988 	{0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8989 	/* enable unsolicited event */
8990 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8991 	{ }
8992 };
8993 
8994 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8995 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8996 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8997 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8998 	{ } /* end */
8999 };
9000 
9001 static void alc888_6st_dell_setup(struct hda_codec *codec)
9002 {
9003 	struct alc_spec *spec = codec->spec;
9004 
9005 	spec->autocfg.hp_pins[0] = 0x1b;
9006 	spec->autocfg.speaker_pins[0] = 0x14;
9007 	spec->autocfg.speaker_pins[1] = 0x15;
9008 	spec->autocfg.speaker_pins[2] = 0x16;
9009 	spec->autocfg.speaker_pins[3] = 0x17;
9010 }
9011 
9012 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9013 {
9014 	struct alc_spec *spec = codec->spec;
9015 
9016 	spec->autocfg.hp_pins[0] = 0x1b;
9017 	spec->autocfg.speaker_pins[0] = 0x14;
9018 	spec->autocfg.speaker_pins[1] = 0x15;
9019 	spec->autocfg.speaker_pins[2] = 0x16;
9020 	spec->autocfg.speaker_pins[3] = 0x17;
9021 	spec->autocfg.speaker_pins[4] = 0x1a;
9022 }
9023 
9024 static void alc883_vaiott_setup(struct hda_codec *codec)
9025 {
9026 	struct alc_spec *spec = codec->spec;
9027 
9028 	spec->autocfg.hp_pins[0] = 0x15;
9029 	spec->autocfg.speaker_pins[0] = 0x14;
9030 	spec->autocfg.speaker_pins[1] = 0x17;
9031 }
9032 
9033 static struct hda_verb alc888_asus_m90v_verbs[] = {
9034 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9035 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9036 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9037 	/* enable unsolicited event */
9038 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9039 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9040 	{ } /* end */
9041 };
9042 
9043 static void alc883_mode2_setup(struct hda_codec *codec)
9044 {
9045 	struct alc_spec *spec = codec->spec;
9046 
9047 	spec->autocfg.hp_pins[0] = 0x1b;
9048 	spec->autocfg.speaker_pins[0] = 0x14;
9049 	spec->autocfg.speaker_pins[1] = 0x15;
9050 	spec->autocfg.speaker_pins[2] = 0x16;
9051 	spec->ext_mic.pin = 0x18;
9052 	spec->int_mic.pin = 0x19;
9053 	spec->ext_mic.mux_idx = 0;
9054 	spec->int_mic.mux_idx = 1;
9055 	spec->auto_mic = 1;
9056 }
9057 
9058 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9059 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9060 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9061 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9062 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9063 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9064 	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9065 	{0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9066 	/* enable unsolicited event */
9067 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9068 	{ } /* end */
9069 };
9070 
9071 static void alc883_eee1601_inithook(struct hda_codec *codec)
9072 {
9073 	struct alc_spec *spec = codec->spec;
9074 
9075 	spec->autocfg.hp_pins[0] = 0x14;
9076 	spec->autocfg.speaker_pins[0] = 0x1b;
9077 	alc_automute_pin(codec);
9078 }
9079 
9080 static struct hda_verb alc889A_mb31_verbs[] = {
9081 	/* Init rear pin (used as headphone output) */
9082 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9083 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9084 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9085 	/* Init line pin (used as output in 4ch and 6ch mode) */
9086 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9087 	/* Init line 2 pin (used as headphone out by default) */
9088 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9089 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9090 	{ } /* end */
9091 };
9092 
9093 /* Mute speakers according to the headphone jack state */
9094 static void alc889A_mb31_automute(struct hda_codec *codec)
9095 {
9096 	unsigned int present;
9097 
9098 	/* Mute only in 2ch or 4ch mode */
9099 	if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9100 	    == 0x00) {
9101 		present = snd_hda_jack_detect(codec, 0x15);
9102 		snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9103 			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9104 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9105 			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9106 	}
9107 }
9108 
9109 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9110 {
9111 	if ((res >> 26) == ALC880_HP_EVENT)
9112 		alc889A_mb31_automute(codec);
9113 }
9114 
9115 
9116 #ifdef CONFIG_SND_HDA_POWER_SAVE
9117 #define alc882_loopbacks	alc880_loopbacks
9118 #endif
9119 
9120 /* pcm configuration: identical with ALC880 */
9121 #define alc882_pcm_analog_playback	alc880_pcm_analog_playback
9122 #define alc882_pcm_analog_capture	alc880_pcm_analog_capture
9123 #define alc882_pcm_digital_playback	alc880_pcm_digital_playback
9124 #define alc882_pcm_digital_capture	alc880_pcm_digital_capture
9125 
9126 static hda_nid_t alc883_slave_dig_outs[] = {
9127 	ALC1200_DIGOUT_NID, 0,
9128 };
9129 
9130 static hda_nid_t alc1200_slave_dig_outs[] = {
9131 	ALC883_DIGOUT_NID, 0,
9132 };
9133 
9134 /*
9135  * configuration and preset
9136  */
9137 static const char *alc882_models[ALC882_MODEL_LAST] = {
9138 	[ALC882_3ST_DIG]	= "3stack-dig",
9139 	[ALC882_6ST_DIG]	= "6stack-dig",
9140 	[ALC882_ARIMA]		= "arima",
9141 	[ALC882_W2JC]		= "w2jc",
9142 	[ALC882_TARGA]		= "targa",
9143 	[ALC882_ASUS_A7J]	= "asus-a7j",
9144 	[ALC882_ASUS_A7M]	= "asus-a7m",
9145 	[ALC885_MACPRO]		= "macpro",
9146 	[ALC885_MB5]		= "mb5",
9147 	[ALC885_MACMINI3]	= "macmini3",
9148 	[ALC885_MBA21]		= "mba21",
9149 	[ALC885_MBP3]		= "mbp3",
9150 	[ALC885_IMAC24]		= "imac24",
9151 	[ALC885_IMAC91]		= "imac91",
9152 	[ALC883_3ST_2ch_DIG]	= "3stack-2ch-dig",
9153 	[ALC883_3ST_6ch_DIG]	= "3stack-6ch-dig",
9154 	[ALC883_3ST_6ch]	= "3stack-6ch",
9155 	[ALC883_6ST_DIG]	= "alc883-6stack-dig",
9156 	[ALC883_TARGA_DIG]	= "targa-dig",
9157 	[ALC883_TARGA_2ch_DIG]	= "targa-2ch-dig",
9158 	[ALC883_TARGA_8ch_DIG]	= "targa-8ch-dig",
9159 	[ALC883_ACER]		= "acer",
9160 	[ALC883_ACER_ASPIRE]	= "acer-aspire",
9161 	[ALC888_ACER_ASPIRE_4930G]	= "acer-aspire-4930g",
9162 	[ALC888_ACER_ASPIRE_6530G]	= "acer-aspire-6530g",
9163 	[ALC888_ACER_ASPIRE_8930G]	= "acer-aspire-8930g",
9164 	[ALC888_ACER_ASPIRE_7730G]	= "acer-aspire-7730g",
9165 	[ALC883_MEDION]		= "medion",
9166 	[ALC883_MEDION_MD2]	= "medion-md2",
9167 	[ALC883_LAPTOP_EAPD]	= "laptop-eapd",
9168 	[ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9169 	[ALC883_LENOVO_NB0763]	= "lenovo-nb0763",
9170 	[ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9171 	[ALC888_LENOVO_SKY] = "lenovo-sky",
9172 	[ALC883_HAIER_W66] 	= "haier-w66",
9173 	[ALC888_3ST_HP]		= "3stack-hp",
9174 	[ALC888_6ST_DELL]	= "6stack-dell",
9175 	[ALC883_MITAC]		= "mitac",
9176 	[ALC883_CLEVO_M540R]	= "clevo-m540r",
9177 	[ALC883_CLEVO_M720]	= "clevo-m720",
9178 	[ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9179 	[ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9180 	[ALC883_3ST_6ch_INTEL]	= "3stack-6ch-intel",
9181 	[ALC889A_INTEL]		= "intel-alc889a",
9182 	[ALC889_INTEL]		= "intel-x58",
9183 	[ALC1200_ASUS_P5Q]	= "asus-p5q",
9184 	[ALC889A_MB31]		= "mb31",
9185 	[ALC883_SONY_VAIO_TT]	= "sony-vaio-tt",
9186 	[ALC882_AUTO]		= "auto",
9187 };
9188 
9189 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9190 	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9191 
9192 	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9193 	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9194 	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9195 	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9196 	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9197 	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9198 	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9199 		ALC888_ACER_ASPIRE_4930G),
9200 	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9201 		ALC888_ACER_ASPIRE_4930G),
9202 	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9203 		ALC888_ACER_ASPIRE_8930G),
9204 	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9205 		ALC888_ACER_ASPIRE_8930G),
9206 	SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9207 	SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9208 	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9209 		ALC888_ACER_ASPIRE_6530G),
9210 	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9211 		ALC888_ACER_ASPIRE_6530G),
9212 	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9213 		ALC888_ACER_ASPIRE_7730G),
9214 	/* default Acer -- disabled as it causes more problems.
9215 	 *    model=auto should work fine now
9216 	 */
9217 	/* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9218 
9219 	SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9220 
9221 	SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9222 	SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9223 	SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9224 	SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9225 	SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9226 	SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9227 
9228 	SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9229 	SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9230 	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9231 	SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9232 	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9233 	SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9234 	SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9235 	SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9236 	SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9237 	SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9238 	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9239 
9240 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9241 	SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9242 	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9243 	SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9244 	SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9245 	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9246 	SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9247 	SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9248 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9249 
9250 	SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9251 	SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9252 	SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9253 	SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9254 	SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9255 	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9256 	SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9257 	SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9258 	SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9259 	SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9260 	SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9261 	SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9262 	SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9263 	SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9264 	SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9265 	SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9266 	SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9267 	SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9268 	SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9269 	SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9270 	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9271 	SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9272 	SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9273 	SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9274 	SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9275 	SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9276 	SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9277 	SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9278 	SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9279 	SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9280 	SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9281 
9282 	SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9283 	SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9284 	SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9285 	SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9286 	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9287 	SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9288 	/* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9289 	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9290 	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9291 		      ALC883_FUJITSU_PI2515),
9292 	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9293 		ALC888_FUJITSU_XA3530),
9294 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9295 	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9296 	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9297 	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9298 	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9299 	SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9300 	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9301 	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9302 	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9303 
9304 	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9305 	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9306 	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9307 	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9308 	SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9309 	SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9310 	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9311 
9312 	{}
9313 };
9314 
9315 /* codec SSID table for Intel Mac */
9316 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9317 	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9318 	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9319 	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9320 	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9321 	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9322 	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9323 	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9324 	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9325 	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9326 	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9327 	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9328 	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9329 	/* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9330 	 * so apparently no perfect solution yet
9331 	 */
9332 	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9333 	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9334 	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9335 	{} /* terminator */
9336 };
9337 
9338 static struct alc_config_preset alc882_presets[] = {
9339 	[ALC882_3ST_DIG] = {
9340 		.mixers = { alc882_base_mixer },
9341 		.init_verbs = { alc882_base_init_verbs,
9342 				alc882_adc1_init_verbs },
9343 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9344 		.dac_nids = alc882_dac_nids,
9345 		.dig_out_nid = ALC882_DIGOUT_NID,
9346 		.dig_in_nid = ALC882_DIGIN_NID,
9347 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9348 		.channel_mode = alc882_ch_modes,
9349 		.need_dac_fix = 1,
9350 		.input_mux = &alc882_capture_source,
9351 	},
9352 	[ALC882_6ST_DIG] = {
9353 		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9354 		.init_verbs = { alc882_base_init_verbs,
9355 				alc882_adc1_init_verbs },
9356 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9357 		.dac_nids = alc882_dac_nids,
9358 		.dig_out_nid = ALC882_DIGOUT_NID,
9359 		.dig_in_nid = ALC882_DIGIN_NID,
9360 		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9361 		.channel_mode = alc882_sixstack_modes,
9362 		.input_mux = &alc882_capture_source,
9363 	},
9364 	[ALC882_ARIMA] = {
9365 		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9366 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9367 				alc882_eapd_verbs },
9368 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9369 		.dac_nids = alc882_dac_nids,
9370 		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9371 		.channel_mode = alc882_sixstack_modes,
9372 		.input_mux = &alc882_capture_source,
9373 	},
9374 	[ALC882_W2JC] = {
9375 		.mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9376 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9377 				alc882_eapd_verbs, alc880_gpio1_init_verbs },
9378 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9379 		.dac_nids = alc882_dac_nids,
9380 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9381 		.channel_mode = alc880_threestack_modes,
9382 		.need_dac_fix = 1,
9383 		.input_mux = &alc882_capture_source,
9384 		.dig_out_nid = ALC882_DIGOUT_NID,
9385 	},
9386 	   [ALC885_MBA21] = {
9387 			.mixers = { alc885_mba21_mixer },
9388 			.init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9389 			.num_dacs = 2,
9390 			.dac_nids = alc882_dac_nids,
9391 			.channel_mode = alc885_mba21_ch_modes,
9392 			.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9393 			.input_mux = &alc882_capture_source,
9394 			.unsol_event = alc_automute_amp_unsol_event,
9395 			.setup = alc885_mba21_setup,
9396 			.init_hook = alc_automute_amp,
9397        },
9398 	[ALC885_MBP3] = {
9399 		.mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9400 		.init_verbs = { alc885_mbp3_init_verbs,
9401 				alc880_gpio1_init_verbs },
9402 		.num_dacs = 2,
9403 		.dac_nids = alc882_dac_nids,
9404 		.hp_nid = 0x04,
9405 		.channel_mode = alc885_mbp_4ch_modes,
9406 		.num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9407 		.input_mux = &alc882_capture_source,
9408 		.dig_out_nid = ALC882_DIGOUT_NID,
9409 		.dig_in_nid = ALC882_DIGIN_NID,
9410 		.unsol_event = alc_automute_amp_unsol_event,
9411 		.setup = alc885_mbp3_setup,
9412 		.init_hook = alc_automute_amp,
9413 	},
9414 	[ALC885_MB5] = {
9415 		.mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9416 		.init_verbs = { alc885_mb5_init_verbs,
9417 				alc880_gpio1_init_verbs },
9418 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9419 		.dac_nids = alc882_dac_nids,
9420 		.channel_mode = alc885_mb5_6ch_modes,
9421 		.num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9422 		.input_mux = &mb5_capture_source,
9423 		.dig_out_nid = ALC882_DIGOUT_NID,
9424 		.dig_in_nid = ALC882_DIGIN_NID,
9425 		.unsol_event = alc_automute_amp_unsol_event,
9426 		.setup = alc885_mb5_setup,
9427 		.init_hook = alc_automute_amp,
9428 	},
9429 	[ALC885_MACMINI3] = {
9430 		.mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9431 		.init_verbs = { alc885_macmini3_init_verbs,
9432 				alc880_gpio1_init_verbs },
9433 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9434 		.dac_nids = alc882_dac_nids,
9435 		.channel_mode = alc885_macmini3_6ch_modes,
9436 		.num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9437 		.input_mux = &macmini3_capture_source,
9438 		.dig_out_nid = ALC882_DIGOUT_NID,
9439 		.dig_in_nid = ALC882_DIGIN_NID,
9440 		.unsol_event = alc_automute_amp_unsol_event,
9441 		.setup = alc885_macmini3_setup,
9442 		.init_hook = alc_automute_amp,
9443 	},
9444 	[ALC885_MACPRO] = {
9445 		.mixers = { alc882_macpro_mixer },
9446 		.init_verbs = { alc882_macpro_init_verbs },
9447 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9448 		.dac_nids = alc882_dac_nids,
9449 		.dig_out_nid = ALC882_DIGOUT_NID,
9450 		.dig_in_nid = ALC882_DIGIN_NID,
9451 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9452 		.channel_mode = alc882_ch_modes,
9453 		.input_mux = &alc882_capture_source,
9454 		.init_hook = alc885_macpro_init_hook,
9455 	},
9456 	[ALC885_IMAC24] = {
9457 		.mixers = { alc885_imac24_mixer },
9458 		.init_verbs = { alc885_imac24_init_verbs },
9459 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9460 		.dac_nids = alc882_dac_nids,
9461 		.dig_out_nid = ALC882_DIGOUT_NID,
9462 		.dig_in_nid = ALC882_DIGIN_NID,
9463 		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9464 		.channel_mode = alc882_ch_modes,
9465 		.input_mux = &alc882_capture_source,
9466 		.unsol_event = alc_automute_amp_unsol_event,
9467 		.setup = alc885_imac24_setup,
9468 		.init_hook = alc885_imac24_init_hook,
9469 	},
9470 	[ALC885_IMAC91] = {
9471 		.mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9472 		.init_verbs = { alc885_imac91_init_verbs,
9473 				alc880_gpio1_init_verbs },
9474 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9475 		.dac_nids = alc882_dac_nids,
9476 		.channel_mode = alc885_mbp_4ch_modes,
9477 		.num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9478 		.input_mux = &alc882_capture_source,
9479 		.dig_out_nid = ALC882_DIGOUT_NID,
9480 		.dig_in_nid = ALC882_DIGIN_NID,
9481 		.unsol_event = alc_automute_amp_unsol_event,
9482 		.setup = alc885_imac91_setup,
9483 		.init_hook = alc_automute_amp,
9484 	},
9485 	[ALC882_TARGA] = {
9486 		.mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9487 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9488 				alc880_gpio3_init_verbs, alc882_targa_verbs},
9489 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9490 		.dac_nids = alc882_dac_nids,
9491 		.dig_out_nid = ALC882_DIGOUT_NID,
9492 		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9493 		.adc_nids = alc882_adc_nids,
9494 		.capsrc_nids = alc882_capsrc_nids,
9495 		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9496 		.channel_mode = alc882_3ST_6ch_modes,
9497 		.need_dac_fix = 1,
9498 		.input_mux = &alc882_capture_source,
9499 		.unsol_event = alc882_targa_unsol_event,
9500 		.setup = alc882_targa_setup,
9501 		.init_hook = alc882_targa_automute,
9502 	},
9503 	[ALC882_ASUS_A7J] = {
9504 		.mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9505 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9506 				alc882_asus_a7j_verbs},
9507 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9508 		.dac_nids = alc882_dac_nids,
9509 		.dig_out_nid = ALC882_DIGOUT_NID,
9510 		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9511 		.adc_nids = alc882_adc_nids,
9512 		.capsrc_nids = alc882_capsrc_nids,
9513 		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9514 		.channel_mode = alc882_3ST_6ch_modes,
9515 		.need_dac_fix = 1,
9516 		.input_mux = &alc882_capture_source,
9517 	},
9518 	[ALC882_ASUS_A7M] = {
9519 		.mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9520 		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9521 				alc882_eapd_verbs, alc880_gpio1_init_verbs,
9522 				alc882_asus_a7m_verbs },
9523 		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9524 		.dac_nids = alc882_dac_nids,
9525 		.dig_out_nid = ALC882_DIGOUT_NID,
9526 		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9527 		.channel_mode = alc880_threestack_modes,
9528 		.need_dac_fix = 1,
9529 		.input_mux = &alc882_capture_source,
9530 	},
9531 	[ALC883_3ST_2ch_DIG] = {
9532 		.mixers = { alc883_3ST_2ch_mixer },
9533 		.init_verbs = { alc883_init_verbs },
9534 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9535 		.dac_nids = alc883_dac_nids,
9536 		.dig_out_nid = ALC883_DIGOUT_NID,
9537 		.dig_in_nid = ALC883_DIGIN_NID,
9538 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9539 		.channel_mode = alc883_3ST_2ch_modes,
9540 		.input_mux = &alc883_capture_source,
9541 	},
9542 	[ALC883_3ST_6ch_DIG] = {
9543 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9544 		.init_verbs = { alc883_init_verbs },
9545 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9546 		.dac_nids = alc883_dac_nids,
9547 		.dig_out_nid = ALC883_DIGOUT_NID,
9548 		.dig_in_nid = ALC883_DIGIN_NID,
9549 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9550 		.channel_mode = alc883_3ST_6ch_modes,
9551 		.need_dac_fix = 1,
9552 		.input_mux = &alc883_capture_source,
9553 	},
9554 	[ALC883_3ST_6ch] = {
9555 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9556 		.init_verbs = { alc883_init_verbs },
9557 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9558 		.dac_nids = alc883_dac_nids,
9559 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9560 		.channel_mode = alc883_3ST_6ch_modes,
9561 		.need_dac_fix = 1,
9562 		.input_mux = &alc883_capture_source,
9563 	},
9564 	[ALC883_3ST_6ch_INTEL] = {
9565 		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9566 		.init_verbs = { alc883_init_verbs },
9567 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9568 		.dac_nids = alc883_dac_nids,
9569 		.dig_out_nid = ALC883_DIGOUT_NID,
9570 		.dig_in_nid = ALC883_DIGIN_NID,
9571 		.slave_dig_outs = alc883_slave_dig_outs,
9572 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9573 		.channel_mode = alc883_3ST_6ch_intel_modes,
9574 		.need_dac_fix = 1,
9575 		.input_mux = &alc883_3stack_6ch_intel,
9576 	},
9577 	[ALC889A_INTEL] = {
9578 		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9579 		.init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9580 				alc_hp15_unsol_verbs },
9581 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9582 		.dac_nids = alc883_dac_nids,
9583 		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9584 		.adc_nids = alc889_adc_nids,
9585 		.dig_out_nid = ALC883_DIGOUT_NID,
9586 		.dig_in_nid = ALC883_DIGIN_NID,
9587 		.slave_dig_outs = alc883_slave_dig_outs,
9588 		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9589 		.channel_mode = alc889_8ch_intel_modes,
9590 		.capsrc_nids = alc889_capsrc_nids,
9591 		.input_mux = &alc889_capture_source,
9592 		.setup = alc889_automute_setup,
9593 		.init_hook = alc_automute_amp,
9594 		.unsol_event = alc_automute_amp_unsol_event,
9595 		.need_dac_fix = 1,
9596 	},
9597 	[ALC889_INTEL] = {
9598 		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9599 		.init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9600 				alc889_eapd_verbs, alc_hp15_unsol_verbs},
9601 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9602 		.dac_nids = alc883_dac_nids,
9603 		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9604 		.adc_nids = alc889_adc_nids,
9605 		.dig_out_nid = ALC883_DIGOUT_NID,
9606 		.dig_in_nid = ALC883_DIGIN_NID,
9607 		.slave_dig_outs = alc883_slave_dig_outs,
9608 		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9609 		.channel_mode = alc889_8ch_intel_modes,
9610 		.capsrc_nids = alc889_capsrc_nids,
9611 		.input_mux = &alc889_capture_source,
9612 		.setup = alc889_automute_setup,
9613 		.init_hook = alc889_intel_init_hook,
9614 		.unsol_event = alc_automute_amp_unsol_event,
9615 		.need_dac_fix = 1,
9616 	},
9617 	[ALC883_6ST_DIG] = {
9618 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9619 		.init_verbs = { alc883_init_verbs },
9620 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9621 		.dac_nids = alc883_dac_nids,
9622 		.dig_out_nid = ALC883_DIGOUT_NID,
9623 		.dig_in_nid = ALC883_DIGIN_NID,
9624 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9625 		.channel_mode = alc883_sixstack_modes,
9626 		.input_mux = &alc883_capture_source,
9627 	},
9628 	[ALC883_TARGA_DIG] = {
9629 		.mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9630 		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9631 				alc883_targa_verbs},
9632 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9633 		.dac_nids = alc883_dac_nids,
9634 		.dig_out_nid = ALC883_DIGOUT_NID,
9635 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9636 		.channel_mode = alc883_3ST_6ch_modes,
9637 		.need_dac_fix = 1,
9638 		.input_mux = &alc883_capture_source,
9639 		.unsol_event = alc883_targa_unsol_event,
9640 		.setup = alc882_targa_setup,
9641 		.init_hook = alc882_targa_automute,
9642 	},
9643 	[ALC883_TARGA_2ch_DIG] = {
9644 		.mixers = { alc883_targa_2ch_mixer},
9645 		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9646 				alc883_targa_verbs},
9647 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9648 		.dac_nids = alc883_dac_nids,
9649 		.adc_nids = alc883_adc_nids_alt,
9650 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9651 		.capsrc_nids = alc883_capsrc_nids,
9652 		.dig_out_nid = ALC883_DIGOUT_NID,
9653 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9654 		.channel_mode = alc883_3ST_2ch_modes,
9655 		.input_mux = &alc883_capture_source,
9656 		.unsol_event = alc883_targa_unsol_event,
9657 		.setup = alc882_targa_setup,
9658 		.init_hook = alc882_targa_automute,
9659 	},
9660 	[ALC883_TARGA_8ch_DIG] = {
9661 		.mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9662 			    alc883_chmode_mixer },
9663 		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9664 				alc883_targa_verbs },
9665 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9666 		.dac_nids = alc883_dac_nids,
9667 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9668 		.adc_nids = alc883_adc_nids_rev,
9669 		.capsrc_nids = alc883_capsrc_nids_rev,
9670 		.dig_out_nid = ALC883_DIGOUT_NID,
9671 		.dig_in_nid = ALC883_DIGIN_NID,
9672 		.num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9673 		.channel_mode = alc883_4ST_8ch_modes,
9674 		.need_dac_fix = 1,
9675 		.input_mux = &alc883_capture_source,
9676 		.unsol_event = alc883_targa_unsol_event,
9677 		.setup = alc882_targa_setup,
9678 		.init_hook = alc882_targa_automute,
9679 	},
9680 	[ALC883_ACER] = {
9681 		.mixers = { alc883_base_mixer },
9682 		/* On TravelMate laptops, GPIO 0 enables the internal speaker
9683 		 * and the headphone jack.  Turn this on and rely on the
9684 		 * standard mute methods whenever the user wants to turn
9685 		 * these outputs off.
9686 		 */
9687 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9688 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9689 		.dac_nids = alc883_dac_nids,
9690 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9691 		.channel_mode = alc883_3ST_2ch_modes,
9692 		.input_mux = &alc883_capture_source,
9693 	},
9694 	[ALC883_ACER_ASPIRE] = {
9695 		.mixers = { alc883_acer_aspire_mixer },
9696 		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9697 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9698 		.dac_nids = alc883_dac_nids,
9699 		.dig_out_nid = ALC883_DIGOUT_NID,
9700 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9701 		.channel_mode = alc883_3ST_2ch_modes,
9702 		.input_mux = &alc883_capture_source,
9703 		.unsol_event = alc_automute_amp_unsol_event,
9704 		.setup = alc883_acer_aspire_setup,
9705 		.init_hook = alc_automute_amp,
9706 	},
9707 	[ALC888_ACER_ASPIRE_4930G] = {
9708 		.mixers = { alc888_base_mixer,
9709 				alc883_chmode_mixer },
9710 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9711 				alc888_acer_aspire_4930g_verbs },
9712 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9713 		.dac_nids = alc883_dac_nids,
9714 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9715 		.adc_nids = alc883_adc_nids_rev,
9716 		.capsrc_nids = alc883_capsrc_nids_rev,
9717 		.dig_out_nid = ALC883_DIGOUT_NID,
9718 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9719 		.channel_mode = alc883_3ST_6ch_modes,
9720 		.need_dac_fix = 1,
9721 		.const_channel_count = 6,
9722 		.num_mux_defs =
9723 			ARRAY_SIZE(alc888_2_capture_sources),
9724 		.input_mux = alc888_2_capture_sources,
9725 		.unsol_event = alc_automute_amp_unsol_event,
9726 		.setup = alc888_acer_aspire_4930g_setup,
9727 		.init_hook = alc_automute_amp,
9728 	},
9729 	[ALC888_ACER_ASPIRE_6530G] = {
9730 		.mixers = { alc888_acer_aspire_6530_mixer },
9731 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9732 				alc888_acer_aspire_6530g_verbs },
9733 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9734 		.dac_nids = alc883_dac_nids,
9735 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9736 		.adc_nids = alc883_adc_nids_rev,
9737 		.capsrc_nids = alc883_capsrc_nids_rev,
9738 		.dig_out_nid = ALC883_DIGOUT_NID,
9739 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9740 		.channel_mode = alc883_3ST_2ch_modes,
9741 		.num_mux_defs =
9742 			ARRAY_SIZE(alc888_2_capture_sources),
9743 		.input_mux = alc888_acer_aspire_6530_sources,
9744 		.unsol_event = alc_automute_amp_unsol_event,
9745 		.setup = alc888_acer_aspire_6530g_setup,
9746 		.init_hook = alc_automute_amp,
9747 	},
9748 	[ALC888_ACER_ASPIRE_8930G] = {
9749 		.mixers = { alc889_acer_aspire_8930g_mixer,
9750 				alc883_chmode_mixer },
9751 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9752 				alc889_acer_aspire_8930g_verbs,
9753 				alc889_eapd_verbs},
9754 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9755 		.dac_nids = alc883_dac_nids,
9756 		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9757 		.adc_nids = alc889_adc_nids,
9758 		.capsrc_nids = alc889_capsrc_nids,
9759 		.dig_out_nid = ALC883_DIGOUT_NID,
9760 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9761 		.channel_mode = alc883_3ST_6ch_modes,
9762 		.need_dac_fix = 1,
9763 		.const_channel_count = 6,
9764 		.num_mux_defs =
9765 			ARRAY_SIZE(alc889_capture_sources),
9766 		.input_mux = alc889_capture_sources,
9767 		.unsol_event = alc_automute_amp_unsol_event,
9768 		.setup = alc889_acer_aspire_8930g_setup,
9769 		.init_hook = alc_automute_amp,
9770 #ifdef CONFIG_SND_HDA_POWER_SAVE
9771 		.power_hook = alc_power_eapd,
9772 #endif
9773 	},
9774 	[ALC888_ACER_ASPIRE_7730G] = {
9775 		.mixers = { alc883_3ST_6ch_mixer,
9776 				alc883_chmode_mixer },
9777 		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9778 				alc888_acer_aspire_7730G_verbs },
9779 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9780 		.dac_nids = alc883_dac_nids,
9781 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9782 		.adc_nids = alc883_adc_nids_rev,
9783 		.capsrc_nids = alc883_capsrc_nids_rev,
9784 		.dig_out_nid = ALC883_DIGOUT_NID,
9785 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9786 		.channel_mode = alc883_3ST_6ch_modes,
9787 		.need_dac_fix = 1,
9788 		.const_channel_count = 6,
9789 		.input_mux = &alc883_capture_source,
9790 		.unsol_event = alc_automute_amp_unsol_event,
9791 		.setup = alc888_acer_aspire_6530g_setup,
9792 		.init_hook = alc_automute_amp,
9793 	},
9794 	[ALC883_MEDION] = {
9795 		.mixers = { alc883_fivestack_mixer,
9796 			    alc883_chmode_mixer },
9797 		.init_verbs = { alc883_init_verbs,
9798 				alc883_medion_eapd_verbs },
9799 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9800 		.dac_nids = alc883_dac_nids,
9801 		.adc_nids = alc883_adc_nids_alt,
9802 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9803 		.capsrc_nids = alc883_capsrc_nids,
9804 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9805 		.channel_mode = alc883_sixstack_modes,
9806 		.input_mux = &alc883_capture_source,
9807 	},
9808 	[ALC883_MEDION_MD2] = {
9809 		.mixers = { alc883_medion_md2_mixer},
9810 		.init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9811 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9812 		.dac_nids = alc883_dac_nids,
9813 		.dig_out_nid = ALC883_DIGOUT_NID,
9814 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9815 		.channel_mode = alc883_3ST_2ch_modes,
9816 		.input_mux = &alc883_capture_source,
9817 		.unsol_event = alc_automute_amp_unsol_event,
9818 		.setup = alc883_medion_md2_setup,
9819 		.init_hook = alc_automute_amp,
9820 	},
9821 	[ALC883_LAPTOP_EAPD] = {
9822 		.mixers = { alc883_base_mixer },
9823 		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9824 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9825 		.dac_nids = alc883_dac_nids,
9826 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9827 		.channel_mode = alc883_3ST_2ch_modes,
9828 		.input_mux = &alc883_capture_source,
9829 	},
9830 	[ALC883_CLEVO_M540R] = {
9831 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9832 		.init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9833 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9834 		.dac_nids = alc883_dac_nids,
9835 		.dig_out_nid = ALC883_DIGOUT_NID,
9836 		.dig_in_nid = ALC883_DIGIN_NID,
9837 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9838 		.channel_mode = alc883_3ST_6ch_clevo_modes,
9839 		.need_dac_fix = 1,
9840 		.input_mux = &alc883_capture_source,
9841 		/* This machine has the hardware HP auto-muting, thus
9842 		 * we need no software mute via unsol event
9843 		 */
9844 	},
9845 	[ALC883_CLEVO_M720] = {
9846 		.mixers = { alc883_clevo_m720_mixer },
9847 		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9848 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9849 		.dac_nids = alc883_dac_nids,
9850 		.dig_out_nid = ALC883_DIGOUT_NID,
9851 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9852 		.channel_mode = alc883_3ST_2ch_modes,
9853 		.input_mux = &alc883_capture_source,
9854 		.unsol_event = alc883_clevo_m720_unsol_event,
9855 		.setup = alc883_clevo_m720_setup,
9856 		.init_hook = alc883_clevo_m720_init_hook,
9857 	},
9858 	[ALC883_LENOVO_101E_2ch] = {
9859 		.mixers = { alc883_lenovo_101e_2ch_mixer},
9860 		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9861 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9862 		.dac_nids = alc883_dac_nids,
9863 		.adc_nids = alc883_adc_nids_alt,
9864 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9865 		.capsrc_nids = alc883_capsrc_nids,
9866 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9867 		.channel_mode = alc883_3ST_2ch_modes,
9868 		.input_mux = &alc883_lenovo_101e_capture_source,
9869 		.unsol_event = alc883_lenovo_101e_unsol_event,
9870 		.init_hook = alc883_lenovo_101e_all_automute,
9871 	},
9872 	[ALC883_LENOVO_NB0763] = {
9873 		.mixers = { alc883_lenovo_nb0763_mixer },
9874 		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9875 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9876 		.dac_nids = alc883_dac_nids,
9877 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9878 		.channel_mode = alc883_3ST_2ch_modes,
9879 		.need_dac_fix = 1,
9880 		.input_mux = &alc883_lenovo_nb0763_capture_source,
9881 		.unsol_event = alc_automute_amp_unsol_event,
9882 		.setup = alc883_medion_md2_setup,
9883 		.init_hook = alc_automute_amp,
9884 	},
9885 	[ALC888_LENOVO_MS7195_DIG] = {
9886 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9887 		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9888 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9889 		.dac_nids = alc883_dac_nids,
9890 		.dig_out_nid = ALC883_DIGOUT_NID,
9891 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9892 		.channel_mode = alc883_3ST_6ch_modes,
9893 		.need_dac_fix = 1,
9894 		.input_mux = &alc883_capture_source,
9895 		.unsol_event = alc883_lenovo_ms7195_unsol_event,
9896 		.init_hook = alc888_lenovo_ms7195_front_automute,
9897 	},
9898 	[ALC883_HAIER_W66] = {
9899 		.mixers = { alc883_targa_2ch_mixer},
9900 		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9901 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9902 		.dac_nids = alc883_dac_nids,
9903 		.dig_out_nid = ALC883_DIGOUT_NID,
9904 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9905 		.channel_mode = alc883_3ST_2ch_modes,
9906 		.input_mux = &alc883_capture_source,
9907 		.unsol_event = alc_automute_amp_unsol_event,
9908 		.setup = alc883_haier_w66_setup,
9909 		.init_hook = alc_automute_amp,
9910 	},
9911 	[ALC888_3ST_HP] = {
9912 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9913 		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9914 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9915 		.dac_nids = alc883_dac_nids,
9916 		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9917 		.channel_mode = alc888_3st_hp_modes,
9918 		.need_dac_fix = 1,
9919 		.input_mux = &alc883_capture_source,
9920 		.unsol_event = alc_automute_amp_unsol_event,
9921 		.setup = alc888_3st_hp_setup,
9922 		.init_hook = alc_automute_amp,
9923 	},
9924 	[ALC888_6ST_DELL] = {
9925 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
9926 		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9927 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9928 		.dac_nids = alc883_dac_nids,
9929 		.dig_out_nid = ALC883_DIGOUT_NID,
9930 		.dig_in_nid = ALC883_DIGIN_NID,
9931 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9932 		.channel_mode = alc883_sixstack_modes,
9933 		.input_mux = &alc883_capture_source,
9934 		.unsol_event = alc_automute_amp_unsol_event,
9935 		.setup = alc888_6st_dell_setup,
9936 		.init_hook = alc_automute_amp,
9937 	},
9938 	[ALC883_MITAC] = {
9939 		.mixers = { alc883_mitac_mixer },
9940 		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9941 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9942 		.dac_nids = alc883_dac_nids,
9943 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9944 		.channel_mode = alc883_3ST_2ch_modes,
9945 		.input_mux = &alc883_capture_source,
9946 		.unsol_event = alc_automute_amp_unsol_event,
9947 		.setup = alc883_mitac_setup,
9948 		.init_hook = alc_automute_amp,
9949 	},
9950 	[ALC883_FUJITSU_PI2515] = {
9951 		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9952 		.init_verbs = { alc883_init_verbs,
9953 				alc883_2ch_fujitsu_pi2515_verbs},
9954 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9955 		.dac_nids = alc883_dac_nids,
9956 		.dig_out_nid = ALC883_DIGOUT_NID,
9957 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9958 		.channel_mode = alc883_3ST_2ch_modes,
9959 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
9960 		.unsol_event = alc_automute_amp_unsol_event,
9961 		.setup = alc883_2ch_fujitsu_pi2515_setup,
9962 		.init_hook = alc_automute_amp,
9963 	},
9964 	[ALC888_FUJITSU_XA3530] = {
9965 		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
9966 		.init_verbs = { alc883_init_verbs,
9967 			alc888_fujitsu_xa3530_verbs },
9968 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9969 		.dac_nids = alc883_dac_nids,
9970 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9971 		.adc_nids = alc883_adc_nids_rev,
9972 		.capsrc_nids = alc883_capsrc_nids_rev,
9973 		.dig_out_nid = ALC883_DIGOUT_NID,
9974 		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9975 		.channel_mode = alc888_4ST_8ch_intel_modes,
9976 		.num_mux_defs =
9977 			ARRAY_SIZE(alc888_2_capture_sources),
9978 		.input_mux = alc888_2_capture_sources,
9979 		.unsol_event = alc_automute_amp_unsol_event,
9980 		.setup = alc888_fujitsu_xa3530_setup,
9981 		.init_hook = alc_automute_amp,
9982 	},
9983 	[ALC888_LENOVO_SKY] = {
9984 		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9985 		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9986 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
9987 		.dac_nids = alc883_dac_nids,
9988 		.dig_out_nid = ALC883_DIGOUT_NID,
9989 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9990 		.channel_mode = alc883_sixstack_modes,
9991 		.need_dac_fix = 1,
9992 		.input_mux = &alc883_lenovo_sky_capture_source,
9993 		.unsol_event = alc_automute_amp_unsol_event,
9994 		.setup = alc888_lenovo_sky_setup,
9995 		.init_hook = alc_automute_amp,
9996 	},
9997 	[ALC888_ASUS_M90V] = {
9998 		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9999 		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10000 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10001 		.dac_nids = alc883_dac_nids,
10002 		.dig_out_nid = ALC883_DIGOUT_NID,
10003 		.dig_in_nid = ALC883_DIGIN_NID,
10004 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10005 		.channel_mode = alc883_3ST_6ch_modes,
10006 		.need_dac_fix = 1,
10007 		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10008 		.unsol_event = alc_sku_unsol_event,
10009 		.setup = alc883_mode2_setup,
10010 		.init_hook = alc_inithook,
10011 	},
10012 	[ALC888_ASUS_EEE1601] = {
10013 		.mixers = { alc883_asus_eee1601_mixer },
10014 		.cap_mixer = alc883_asus_eee1601_cap_mixer,
10015 		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10016 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10017 		.dac_nids = alc883_dac_nids,
10018 		.dig_out_nid = ALC883_DIGOUT_NID,
10019 		.dig_in_nid = ALC883_DIGIN_NID,
10020 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10021 		.channel_mode = alc883_3ST_2ch_modes,
10022 		.need_dac_fix = 1,
10023 		.input_mux = &alc883_asus_eee1601_capture_source,
10024 		.unsol_event = alc_sku_unsol_event,
10025 		.init_hook = alc883_eee1601_inithook,
10026 	},
10027 	[ALC1200_ASUS_P5Q] = {
10028 		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10029 		.init_verbs = { alc883_init_verbs },
10030 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10031 		.dac_nids = alc883_dac_nids,
10032 		.dig_out_nid = ALC1200_DIGOUT_NID,
10033 		.dig_in_nid = ALC883_DIGIN_NID,
10034 		.slave_dig_outs = alc1200_slave_dig_outs,
10035 		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10036 		.channel_mode = alc883_sixstack_modes,
10037 		.input_mux = &alc883_capture_source,
10038 	},
10039 	[ALC889A_MB31] = {
10040 		.mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10041 		.init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10042 			alc880_gpio1_init_verbs },
10043 		.adc_nids = alc883_adc_nids,
10044 		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10045 		.capsrc_nids = alc883_capsrc_nids,
10046 		.dac_nids = alc883_dac_nids,
10047 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10048 		.channel_mode = alc889A_mb31_6ch_modes,
10049 		.num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10050 		.input_mux = &alc889A_mb31_capture_source,
10051 		.dig_out_nid = ALC883_DIGOUT_NID,
10052 		.unsol_event = alc889A_mb31_unsol_event,
10053 		.init_hook = alc889A_mb31_automute,
10054 	},
10055 	[ALC883_SONY_VAIO_TT] = {
10056 		.mixers = { alc883_vaiott_mixer },
10057 		.init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10058 		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10059 		.dac_nids = alc883_dac_nids,
10060 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10061 		.channel_mode = alc883_3ST_2ch_modes,
10062 		.input_mux = &alc883_capture_source,
10063 		.unsol_event = alc_automute_amp_unsol_event,
10064 		.setup = alc883_vaiott_setup,
10065 		.init_hook = alc_automute_amp,
10066 	},
10067 };
10068 
10069 
10070 /*
10071  * Pin config fixes
10072  */
10073 enum {
10074 	PINFIX_ABIT_AW9D_MAX
10075 };
10076 
10077 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
10078 	{ 0x15, 0x01080104 }, /* side */
10079 	{ 0x16, 0x01011012 }, /* rear */
10080 	{ 0x17, 0x01016011 }, /* clfe */
10081 	{ }
10082 };
10083 
10084 static const struct alc_fixup alc882_fixups[] = {
10085 	[PINFIX_ABIT_AW9D_MAX] = {
10086 		.pins = alc882_abit_aw9d_pinfix
10087 	},
10088 };
10089 
10090 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10091 	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10092 	{}
10093 };
10094 
10095 /*
10096  * BIOS auto configuration
10097  */
10098 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10099 						const struct auto_pin_cfg *cfg)
10100 {
10101 	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10102 }
10103 
10104 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10105 					      hda_nid_t nid, int pin_type,
10106 					      int dac_idx)
10107 {
10108 	/* set as output */
10109 	struct alc_spec *spec = codec->spec;
10110 	int idx;
10111 
10112 	alc_set_pin_output(codec, nid, pin_type);
10113 	if (dac_idx >= spec->multiout.num_dacs)
10114 		return;
10115 	if (spec->multiout.dac_nids[dac_idx] == 0x25)
10116 		idx = 4;
10117 	else
10118 		idx = spec->multiout.dac_nids[dac_idx] - 2;
10119 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10120 
10121 }
10122 
10123 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10124 {
10125 	struct alc_spec *spec = codec->spec;
10126 	int i;
10127 
10128 	for (i = 0; i <= HDA_SIDE; i++) {
10129 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
10130 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
10131 		if (nid)
10132 			alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10133 							  i);
10134 	}
10135 }
10136 
10137 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10138 {
10139 	struct alc_spec *spec = codec->spec;
10140 	hda_nid_t pin;
10141 
10142 	pin = spec->autocfg.hp_pins[0];
10143 	if (pin) /* connect to front */
10144 		/* use dac 0 */
10145 		alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
10146 	pin = spec->autocfg.speaker_pins[0];
10147 	if (pin)
10148 		alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
10149 }
10150 
10151 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10152 {
10153 	struct alc_spec *spec = codec->spec;
10154 	int i;
10155 
10156 	for (i = 0; i < AUTO_PIN_LAST; i++) {
10157 		hda_nid_t nid = spec->autocfg.input_pins[i];
10158 		if (!nid)
10159 			continue;
10160 		alc_set_input_pin(codec, nid, i);
10161 		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10162 			snd_hda_codec_write(codec, nid, 0,
10163 					    AC_VERB_SET_AMP_GAIN_MUTE,
10164 					    AMP_OUT_MUTE);
10165 	}
10166 }
10167 
10168 static void alc882_auto_init_input_src(struct hda_codec *codec)
10169 {
10170 	struct alc_spec *spec = codec->spec;
10171 	int c;
10172 
10173 	for (c = 0; c < spec->num_adc_nids; c++) {
10174 		hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10175 		hda_nid_t nid = spec->capsrc_nids[c];
10176 		unsigned int mux_idx;
10177 		const struct hda_input_mux *imux;
10178 		int conns, mute, idx, item;
10179 
10180 		conns = snd_hda_get_connections(codec, nid, conn_list,
10181 						ARRAY_SIZE(conn_list));
10182 		if (conns < 0)
10183 			continue;
10184 		mux_idx = c >= spec->num_mux_defs ? 0 : c;
10185 		imux = &spec->input_mux[mux_idx];
10186 		if (!imux->num_items && mux_idx > 0)
10187 			imux = &spec->input_mux[0];
10188 		for (idx = 0; idx < conns; idx++) {
10189 			/* if the current connection is the selected one,
10190 			 * unmute it as default - otherwise mute it
10191 			 */
10192 			mute = AMP_IN_MUTE(idx);
10193 			for (item = 0; item < imux->num_items; item++) {
10194 				if (imux->items[item].index == idx) {
10195 					if (spec->cur_mux[c] == item)
10196 						mute = AMP_IN_UNMUTE(idx);
10197 					break;
10198 				}
10199 			}
10200 			/* check if we have a selector or mixer
10201 			 * we could check for the widget type instead, but
10202 			 * just check for Amp-In presence (in case of mixer
10203 			 * without amp-in there is something wrong, this
10204 			 * function shouldn't be used or capsrc nid is wrong)
10205 			 */
10206 			if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10207 				snd_hda_codec_write(codec, nid, 0,
10208 						    AC_VERB_SET_AMP_GAIN_MUTE,
10209 						    mute);
10210 			else if (mute != AMP_IN_MUTE(idx))
10211 				snd_hda_codec_write(codec, nid, 0,
10212 						    AC_VERB_SET_CONNECT_SEL,
10213 						    idx);
10214 		}
10215 	}
10216 }
10217 
10218 /* add mic boosts if needed */
10219 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10220 {
10221 	struct alc_spec *spec = codec->spec;
10222 	int err;
10223 	hda_nid_t nid;
10224 
10225 	nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
10226 	if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10227 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
10228 				  "Mic Boost",
10229 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10230 		if (err < 0)
10231 			return err;
10232 	}
10233 	nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
10234 	if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10235 		err = add_control(spec, ALC_CTL_WIDGET_VOL,
10236 				  "Front Mic Boost",
10237 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10238 		if (err < 0)
10239 			return err;
10240 	}
10241 	return 0;
10242 }
10243 
10244 /* almost identical with ALC880 parser... */
10245 static int alc882_parse_auto_config(struct hda_codec *codec)
10246 {
10247 	struct alc_spec *spec = codec->spec;
10248 	static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10249 	int i, err;
10250 
10251 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10252 					   alc882_ignore);
10253 	if (err < 0)
10254 		return err;
10255 	if (!spec->autocfg.line_outs)
10256 		return 0; /* can't find valid BIOS pin config */
10257 
10258 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10259 	if (err < 0)
10260 		return err;
10261 	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10262 	if (err < 0)
10263 		return err;
10264 	err = alc880_auto_create_extra_out(spec,
10265 					   spec->autocfg.speaker_pins[0],
10266 					   "Speaker");
10267 	if (err < 0)
10268 		return err;
10269 	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10270 					   "Headphone");
10271 	if (err < 0)
10272 		return err;
10273 	err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10274 	if (err < 0)
10275 		return err;
10276 
10277 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10278 
10279 	/* check multiple SPDIF-out (for recent codecs) */
10280 	for (i = 0; i < spec->autocfg.dig_outs; i++) {
10281 		hda_nid_t dig_nid;
10282 		err = snd_hda_get_connections(codec,
10283 					      spec->autocfg.dig_out_pins[i],
10284 					      &dig_nid, 1);
10285 		if (err < 0)
10286 			continue;
10287 		if (!i)
10288 			spec->multiout.dig_out_nid = dig_nid;
10289 		else {
10290 			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
10291 			if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
10292 				break;
10293 			spec->slave_dig_outs[i - 1] = dig_nid;
10294 		}
10295 	}
10296 	if (spec->autocfg.dig_in_pin)
10297 		spec->dig_in_nid = ALC880_DIGIN_NID;
10298 
10299 	if (spec->kctls.list)
10300 		add_mixer(spec, spec->kctls.list);
10301 
10302 	add_verb(spec, alc883_auto_init_verbs);
10303 	/* if ADC 0x07 is available, initialize it, too */
10304 	if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10305 		add_verb(spec, alc882_adc1_init_verbs);
10306 
10307 	spec->num_mux_defs = 1;
10308 	spec->input_mux = &spec->private_imux[0];
10309 
10310 	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10311 
10312 	err = alc_auto_add_mic_boost(codec);
10313 	if (err < 0)
10314 		return err;
10315 
10316 	return 1; /* config found */
10317 }
10318 
10319 /* additional initialization for auto-configuration model */
10320 static void alc882_auto_init(struct hda_codec *codec)
10321 {
10322 	struct alc_spec *spec = codec->spec;
10323 	alc882_auto_init_multi_out(codec);
10324 	alc882_auto_init_hp_out(codec);
10325 	alc882_auto_init_analog_input(codec);
10326 	alc882_auto_init_input_src(codec);
10327 	if (spec->unsol_event)
10328 		alc_inithook(codec);
10329 }
10330 
10331 static int patch_alc882(struct hda_codec *codec)
10332 {
10333 	struct alc_spec *spec;
10334 	int err, board_config;
10335 
10336 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10337 	if (spec == NULL)
10338 		return -ENOMEM;
10339 
10340 	codec->spec = spec;
10341 
10342 	switch (codec->vendor_id) {
10343 	case 0x10ec0882:
10344 	case 0x10ec0885:
10345 		break;
10346 	default:
10347 		/* ALC883 and variants */
10348 		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10349 		break;
10350 	}
10351 
10352 	board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10353 						  alc882_models,
10354 						  alc882_cfg_tbl);
10355 
10356 	if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10357 		board_config = snd_hda_check_board_codec_sid_config(codec,
10358 			ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10359 
10360 	if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10361 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10362 		       codec->chip_name);
10363 		board_config = ALC882_AUTO;
10364 	}
10365 
10366 	alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10367 
10368 	if (board_config == ALC882_AUTO) {
10369 		/* automatic parse from the BIOS config */
10370 		err = alc882_parse_auto_config(codec);
10371 		if (err < 0) {
10372 			alc_free(codec);
10373 			return err;
10374 		} else if (!err) {
10375 			printk(KERN_INFO
10376 			       "hda_codec: Cannot set up configuration "
10377 			       "from BIOS.  Using base mode...\n");
10378 			board_config = ALC882_3ST_DIG;
10379 		}
10380 	}
10381 
10382 	err = snd_hda_attach_beep_device(codec, 0x1);
10383 	if (err < 0) {
10384 		alc_free(codec);
10385 		return err;
10386 	}
10387 
10388 	if (board_config != ALC882_AUTO)
10389 		setup_preset(codec, &alc882_presets[board_config]);
10390 
10391 	spec->stream_analog_playback = &alc882_pcm_analog_playback;
10392 	spec->stream_analog_capture = &alc882_pcm_analog_capture;
10393 	/* FIXME: setup DAC5 */
10394 	/*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10395 	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10396 
10397 	spec->stream_digital_playback = &alc882_pcm_digital_playback;
10398 	spec->stream_digital_capture = &alc882_pcm_digital_capture;
10399 
10400 	if (codec->vendor_id == 0x10ec0888)
10401 		spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10402 
10403 	if (!spec->adc_nids && spec->input_mux) {
10404 		int i, j;
10405 		spec->num_adc_nids = 0;
10406 		for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10407 			const struct hda_input_mux *imux = spec->input_mux;
10408 			hda_nid_t cap;
10409 			hda_nid_t items[16];
10410 			hda_nid_t nid = alc882_adc_nids[i];
10411 			unsigned int wcap = get_wcaps(codec, nid);
10412 			/* get type */
10413 			wcap = get_wcaps_type(wcap);
10414 			if (wcap != AC_WID_AUD_IN)
10415 				continue;
10416 			spec->private_adc_nids[spec->num_adc_nids] = nid;
10417 			err = snd_hda_get_connections(codec, nid, &cap, 1);
10418 			if (err < 0)
10419 				continue;
10420 			err = snd_hda_get_connections(codec, cap, items,
10421 						      ARRAY_SIZE(items));
10422 			if (err < 0)
10423 				continue;
10424 			for (j = 0; j < imux->num_items; j++)
10425 				if (imux->items[j].index >= err)
10426 					break;
10427 			if (j < imux->num_items)
10428 				continue;
10429 			spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10430 			spec->num_adc_nids++;
10431 		}
10432 		spec->adc_nids = spec->private_adc_nids;
10433 		spec->capsrc_nids = spec->private_capsrc_nids;
10434 	}
10435 
10436 	set_capture_mixer(codec);
10437 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10438 
10439 	spec->vmaster_nid = 0x0c;
10440 
10441 	codec->patch_ops = alc_patch_ops;
10442 	if (board_config == ALC882_AUTO)
10443 		spec->init_hook = alc882_auto_init;
10444 #ifdef CONFIG_SND_HDA_POWER_SAVE
10445 	if (!spec->loopback.amplist)
10446 		spec->loopback.amplist = alc882_loopbacks;
10447 #endif
10448 
10449 	return 0;
10450 }
10451 
10452 
10453 /*
10454  * ALC262 support
10455  */
10456 
10457 #define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
10458 #define ALC262_DIGIN_NID	ALC880_DIGIN_NID
10459 
10460 #define alc262_dac_nids		alc260_dac_nids
10461 #define alc262_adc_nids		alc882_adc_nids
10462 #define alc262_adc_nids_alt	alc882_adc_nids_alt
10463 #define alc262_capsrc_nids	alc882_capsrc_nids
10464 #define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
10465 
10466 #define alc262_modes		alc260_modes
10467 #define alc262_capture_source	alc882_capture_source
10468 
10469 static hda_nid_t alc262_dmic_adc_nids[1] = {
10470 	/* ADC0 */
10471 	0x09
10472 };
10473 
10474 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10475 
10476 static struct snd_kcontrol_new alc262_base_mixer[] = {
10477 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10478 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10479 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10480 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10481 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10482 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10483 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10484 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10485 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10486 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10487 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10488 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10489 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10490 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10491 	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10492 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10493 	{ } /* end */
10494 };
10495 
10496 /* update HP, line and mono-out pins according to the master switch */
10497 static void alc262_hp_master_update(struct hda_codec *codec)
10498 {
10499 	struct alc_spec *spec = codec->spec;
10500 	int val = spec->master_sw;
10501 
10502 	/* HP & line-out */
10503 	snd_hda_codec_write_cache(codec, 0x1b, 0,
10504 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10505 				  val ? PIN_HP : 0);
10506 	snd_hda_codec_write_cache(codec, 0x15, 0,
10507 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10508 				  val ? PIN_HP : 0);
10509 	/* mono (speaker) depending on the HP jack sense */
10510 	val = val && !spec->jack_present;
10511 	snd_hda_codec_write_cache(codec, 0x16, 0,
10512 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
10513 				  val ? PIN_OUT : 0);
10514 }
10515 
10516 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10517 {
10518 	struct alc_spec *spec = codec->spec;
10519 
10520 	spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10521 	alc262_hp_master_update(codec);
10522 }
10523 
10524 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10525 {
10526 	if ((res >> 26) != ALC880_HP_EVENT)
10527 		return;
10528 	alc262_hp_bpc_automute(codec);
10529 }
10530 
10531 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10532 {
10533 	struct alc_spec *spec = codec->spec;
10534 
10535 	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10536 	alc262_hp_master_update(codec);
10537 }
10538 
10539 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10540 					   unsigned int res)
10541 {
10542 	if ((res >> 26) != ALC880_HP_EVENT)
10543 		return;
10544 	alc262_hp_wildwest_automute(codec);
10545 }
10546 
10547 #define alc262_hp_master_sw_get		alc260_hp_master_sw_get
10548 
10549 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10550 				   struct snd_ctl_elem_value *ucontrol)
10551 {
10552 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10553 	struct alc_spec *spec = codec->spec;
10554 	int val = !!*ucontrol->value.integer.value;
10555 
10556 	if (val == spec->master_sw)
10557 		return 0;
10558 	spec->master_sw = val;
10559 	alc262_hp_master_update(codec);
10560 	return 1;
10561 }
10562 
10563 #define ALC262_HP_MASTER_SWITCH					\
10564 	{							\
10565 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
10566 		.name = "Master Playback Switch",		\
10567 		.info = snd_ctl_boolean_mono_info,		\
10568 		.get = alc262_hp_master_sw_get,			\
10569 		.put = alc262_hp_master_sw_put,			\
10570 	}, \
10571 	{							\
10572 		.iface = NID_MAPPING,				\
10573 		.name = "Master Playback Switch",		\
10574 		.private_value = 0x15 | (0x16 << 8) | (0x1b << 16),	\
10575 	}
10576 
10577 
10578 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10579 	ALC262_HP_MASTER_SWITCH,
10580 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10581 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10582 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10583 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10584 			      HDA_OUTPUT),
10585 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10586 			    HDA_OUTPUT),
10587 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10588 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10589 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10590 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10591 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10592 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10593 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10594 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10595 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10596 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10597 	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10598 	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10599 	{ } /* end */
10600 };
10601 
10602 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10603 	ALC262_HP_MASTER_SWITCH,
10604 	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10605 	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10606 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10607 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10608 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10609 			      HDA_OUTPUT),
10610 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10611 			    HDA_OUTPUT),
10612 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10613 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10614 	HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10615 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10616 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10617 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10618 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10619 	{ } /* end */
10620 };
10621 
10622 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10623 	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10624 	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10625 	HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10626 	{ } /* end */
10627 };
10628 
10629 /* mute/unmute internal speaker according to the hp jack and mute state */
10630 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10631 {
10632 	struct alc_spec *spec = codec->spec;
10633 
10634 	spec->autocfg.hp_pins[0] = 0x15;
10635 	spec->autocfg.speaker_pins[0] = 0x14;
10636 }
10637 
10638 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10639 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10640 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10641 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10642 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10643 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10644 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10645 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10646 	{ } /* end */
10647 };
10648 
10649 static struct hda_verb alc262_hp_t5735_verbs[] = {
10650 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10651 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10652 
10653 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10654 	{ }
10655 };
10656 
10657 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10658 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10659 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10660 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10661 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10662 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10663 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10664 	{ } /* end */
10665 };
10666 
10667 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10668 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10669 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10670 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10671 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10672 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10673 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10674 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10675 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10676 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10677 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10678 	{}
10679 };
10680 
10681 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10682 	.num_items = 1,
10683 	.items = {
10684 		{ "Line", 0x1 },
10685 	},
10686 };
10687 
10688 /* bind hp and internal speaker mute (with plug check) as master switch */
10689 static void alc262_hippo_master_update(struct hda_codec *codec)
10690 {
10691 	struct alc_spec *spec = codec->spec;
10692 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10693 	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10694 	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10695 	unsigned int mute;
10696 
10697 	/* HP */
10698 	mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10699 	snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10700 				 HDA_AMP_MUTE, mute);
10701 	/* mute internal speaker per jack sense */
10702 	if (spec->jack_present)
10703 		mute = HDA_AMP_MUTE;
10704 	if (line_nid)
10705 		snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10706 					 HDA_AMP_MUTE, mute);
10707 	if (speaker_nid && speaker_nid != line_nid)
10708 		snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10709 					 HDA_AMP_MUTE, mute);
10710 }
10711 
10712 #define alc262_hippo_master_sw_get	alc262_hp_master_sw_get
10713 
10714 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10715 				      struct snd_ctl_elem_value *ucontrol)
10716 {
10717 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10718 	struct alc_spec *spec = codec->spec;
10719 	int val = !!*ucontrol->value.integer.value;
10720 
10721 	if (val == spec->master_sw)
10722 		return 0;
10723 	spec->master_sw = val;
10724 	alc262_hippo_master_update(codec);
10725 	return 1;
10726 }
10727 
10728 #define ALC262_HIPPO_MASTER_SWITCH				\
10729 	{							\
10730 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
10731 		.name = "Master Playback Switch",		\
10732 		.info = snd_ctl_boolean_mono_info,		\
10733 		.get = alc262_hippo_master_sw_get,		\
10734 		.put = alc262_hippo_master_sw_put,		\
10735 	},							\
10736 	{							\
10737 		.iface = NID_MAPPING,				\
10738 		.name = "Master Playback Switch",		\
10739 		.subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
10740 			     (SUBDEV_SPEAKER(0) << 16), \
10741 	}
10742 
10743 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10744 	ALC262_HIPPO_MASTER_SWITCH,
10745 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10746 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10747 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10748 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10749 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, 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("Mic Boost", 0x18, 0, HDA_INPUT),
10753 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10754 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10755 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10756 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10757 	{ } /* end */
10758 };
10759 
10760 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10761 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10762 	ALC262_HIPPO_MASTER_SWITCH,
10763 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10764 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10765 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10766 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10767 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10768 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10769 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10770 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10771 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10772 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10773 	{ } /* end */
10774 };
10775 
10776 /* mute/unmute internal speaker according to the hp jack and mute state */
10777 static void alc262_hippo_automute(struct hda_codec *codec)
10778 {
10779 	struct alc_spec *spec = codec->spec;
10780 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10781 
10782 	spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10783 	alc262_hippo_master_update(codec);
10784 }
10785 
10786 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10787 {
10788 	if ((res >> 26) != ALC880_HP_EVENT)
10789 		return;
10790 	alc262_hippo_automute(codec);
10791 }
10792 
10793 static void alc262_hippo_setup(struct hda_codec *codec)
10794 {
10795 	struct alc_spec *spec = codec->spec;
10796 
10797 	spec->autocfg.hp_pins[0] = 0x15;
10798 	spec->autocfg.speaker_pins[0] = 0x14;
10799 }
10800 
10801 static void alc262_hippo1_setup(struct hda_codec *codec)
10802 {
10803 	struct alc_spec *spec = codec->spec;
10804 
10805 	spec->autocfg.hp_pins[0] = 0x1b;
10806 	spec->autocfg.speaker_pins[0] = 0x14;
10807 }
10808 
10809 
10810 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10811 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10812 	ALC262_HIPPO_MASTER_SWITCH,
10813 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10814 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10815 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10816 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10817 	{ } /* end */
10818 };
10819 
10820 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10821 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10822 	ALC262_HIPPO_MASTER_SWITCH,
10823 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10824 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10825 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10826 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10827 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10828 	{ } /* end */
10829 };
10830 
10831 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10832 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10833 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10834 	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10835 	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10836 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10837 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10838 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10839 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10840 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10841 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10842 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10843 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10844 	{ } /* end */
10845 };
10846 
10847 static struct hda_verb alc262_tyan_verbs[] = {
10848 	/* Headphone automute */
10849 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10850 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10851 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10852 
10853 	/* P11 AUX_IN, white 4-pin connector */
10854 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10855 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10856 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10857 	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10858 
10859 	{}
10860 };
10861 
10862 /* unsolicited event for HP jack sensing */
10863 static void alc262_tyan_setup(struct hda_codec *codec)
10864 {
10865 	struct alc_spec *spec = codec->spec;
10866 
10867 	spec->autocfg.hp_pins[0] = 0x1b;
10868 	spec->autocfg.speaker_pins[0] = 0x15;
10869 }
10870 
10871 
10872 #define alc262_capture_mixer		alc882_capture_mixer
10873 #define alc262_capture_alt_mixer	alc882_capture_alt_mixer
10874 
10875 /*
10876  * generic initialization of ADC, input mixers and output mixers
10877  */
10878 static struct hda_verb alc262_init_verbs[] = {
10879 	/*
10880 	 * Unmute ADC0-2 and set the default input to mic-in
10881 	 */
10882 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10883 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10884 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10885 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10886 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10887 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10888 
10889 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10890 	 * mixer widget
10891 	 * Note: PASD motherboards uses the Line In 2 as the input for
10892 	 * front panel mic (mic 2)
10893 	 */
10894 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10895 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10896 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10897 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10898 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10899 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10900 
10901 	/*
10902 	 * Set up output mixers (0x0c - 0x0e)
10903 	 */
10904 	/* set vol=0 to output mixers */
10905 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10906 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10907 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10908 	/* set up input amps for analog loopback */
10909 	/* Amp Indices: DAC = 0, mixer = 1 */
10910 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10911 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10912 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10913 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10914 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10915 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10916 
10917 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10918 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10919 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10920 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10921 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10922 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10923 
10924 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10925 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10926 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10927 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10928 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10929 
10930 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10931 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10932 
10933 	/* FIXME: use matrix-type input source selection */
10934 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10935 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10936 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10937 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10938 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10939 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10940 	/* Input mixer2 */
10941 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10942 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10943 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10944 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10945 	/* Input mixer3 */
10946 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10947 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10948 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10949 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10950 
10951 	{ }
10952 };
10953 
10954 static struct hda_verb alc262_eapd_verbs[] = {
10955 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10956 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10957 	{ }
10958 };
10959 
10960 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10961 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10962 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10963 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10964 
10965 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10966 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10967 	{}
10968 };
10969 
10970 static struct hda_verb alc262_sony_unsol_verbs[] = {
10971 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10972 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10973 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
10974 
10975 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10976 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10977 	{}
10978 };
10979 
10980 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10981 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10982 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10983 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10984 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10985 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10986 	{ } /* end */
10987 };
10988 
10989 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10990 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10991 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10992 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10993 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10994 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10995 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10996 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10997 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10998 	{}
10999 };
11000 
11001 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11002 {
11003 	struct alc_spec *spec = codec->spec;
11004 
11005 	spec->autocfg.hp_pins[0] = 0x15;
11006 	spec->autocfg.speaker_pins[0] = 0x14;
11007 	spec->ext_mic.pin = 0x18;
11008 	spec->ext_mic.mux_idx = 0;
11009 	spec->int_mic.pin = 0x12;
11010 	spec->int_mic.mux_idx = 9;
11011 	spec->auto_mic = 1;
11012 }
11013 
11014 /*
11015  * nec model
11016  *  0x15 = headphone
11017  *  0x16 = internal speaker
11018  *  0x18 = external mic
11019  */
11020 
11021 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11022 	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11023 	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11024 
11025 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11026 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11027 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11028 
11029 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11030 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11031 	{ } /* end */
11032 };
11033 
11034 static struct hda_verb alc262_nec_verbs[] = {
11035 	/* Unmute Speaker */
11036 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11037 
11038 	/* Headphone */
11039 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11040 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11041 
11042 	/* External mic to headphone */
11043 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11044 	/* External mic to speaker */
11045 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11046 	{}
11047 };
11048 
11049 /*
11050  * fujitsu model
11051  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11052  *  0x1b = port replicator headphone out
11053  */
11054 
11055 #define ALC_HP_EVENT	0x37
11056 
11057 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11058 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11059 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11060 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11061 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11062 	{}
11063 };
11064 
11065 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11066 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11067 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11068 	{}
11069 };
11070 
11071 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11072 	/* Front Mic pin: input vref at 50% */
11073 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11074 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11075 	{}
11076 };
11077 
11078 static struct hda_input_mux alc262_fujitsu_capture_source = {
11079 	.num_items = 3,
11080 	.items = {
11081 		{ "Mic", 0x0 },
11082 		{ "Int Mic", 0x1 },
11083 		{ "CD", 0x4 },
11084 	},
11085 };
11086 
11087 static struct hda_input_mux alc262_HP_capture_source = {
11088 	.num_items = 5,
11089 	.items = {
11090 		{ "Mic", 0x0 },
11091 		{ "Front Mic", 0x1 },
11092 		{ "Line", 0x2 },
11093 		{ "CD", 0x4 },
11094 		{ "AUX IN", 0x6 },
11095 	},
11096 };
11097 
11098 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11099 	.num_items = 4,
11100 	.items = {
11101 		{ "Mic", 0x0 },
11102 		{ "Front Mic", 0x2 },
11103 		{ "Line", 0x1 },
11104 		{ "CD", 0x4 },
11105 	},
11106 };
11107 
11108 /* mute/unmute internal speaker according to the hp jacks and mute state */
11109 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11110 {
11111 	struct alc_spec *spec = codec->spec;
11112 	unsigned int mute;
11113 
11114 	if (force || !spec->sense_updated) {
11115 		spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11116 				     snd_hda_jack_detect(codec, 0x1b);
11117 		spec->sense_updated = 1;
11118 	}
11119 	/* unmute internal speaker only if both HPs are unplugged and
11120 	 * master switch is on
11121 	 */
11122 	if (spec->jack_present)
11123 		mute = HDA_AMP_MUTE;
11124 	else
11125 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11126 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11127 				 HDA_AMP_MUTE, mute);
11128 }
11129 
11130 /* unsolicited event for HP jack sensing */
11131 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11132 				       unsigned int res)
11133 {
11134 	if ((res >> 26) != ALC_HP_EVENT)
11135 		return;
11136 	alc262_fujitsu_automute(codec, 1);
11137 }
11138 
11139 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11140 {
11141 	alc262_fujitsu_automute(codec, 1);
11142 }
11143 
11144 /* bind volumes of both NID 0x0c and 0x0d */
11145 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11146 	.ops = &snd_hda_bind_vol,
11147 	.values = {
11148 		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11149 		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11150 		0
11151 	},
11152 };
11153 
11154 /* mute/unmute internal speaker according to the hp jack and mute state */
11155 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11156 {
11157 	struct alc_spec *spec = codec->spec;
11158 	unsigned int mute;
11159 
11160 	if (force || !spec->sense_updated) {
11161 		spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11162 		spec->sense_updated = 1;
11163 	}
11164 	if (spec->jack_present) {
11165 		/* mute internal speaker */
11166 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11167 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11168 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11169 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11170 	} else {
11171 		/* unmute internal speaker if necessary */
11172 		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11173 		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11174 					 HDA_AMP_MUTE, mute);
11175 		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11176 					 HDA_AMP_MUTE, mute);
11177 	}
11178 }
11179 
11180 /* unsolicited event for HP jack sensing */
11181 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11182 				       unsigned int res)
11183 {
11184 	if ((res >> 26) != ALC_HP_EVENT)
11185 		return;
11186 	alc262_lenovo_3000_automute(codec, 1);
11187 }
11188 
11189 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11190 				  int dir, int idx, long *valp)
11191 {
11192 	int i, change = 0;
11193 
11194 	for (i = 0; i < 2; i++, valp++)
11195 		change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11196 						   HDA_AMP_MUTE,
11197 						   *valp ? 0 : HDA_AMP_MUTE);
11198 	return change;
11199 }
11200 
11201 /* bind hp and internal speaker mute (with plug check) */
11202 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11203 					 struct snd_ctl_elem_value *ucontrol)
11204 {
11205 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11206 	long *valp = ucontrol->value.integer.value;
11207 	int change;
11208 
11209 	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11210 	change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11211 	if (change)
11212 		alc262_fujitsu_automute(codec, 0);
11213 	return change;
11214 }
11215 
11216 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11217 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11218 	{
11219 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11220 		.name = "Master Playback Switch",
11221 		.subdevice = HDA_SUBDEV_AMP_FLAG,
11222 		.info = snd_hda_mixer_amp_switch_info,
11223 		.get = snd_hda_mixer_amp_switch_get,
11224 		.put = alc262_fujitsu_master_sw_put,
11225 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11226 	},
11227 	{
11228 		.iface = NID_MAPPING,
11229 		.name = "Master Playback Switch",
11230 		.private_value = 0x1b,
11231 	},
11232 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11233 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11234 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11235 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11236 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11237 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11238 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11239 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11240 	{ } /* end */
11241 };
11242 
11243 /* bind hp and internal speaker mute (with plug check) */
11244 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11245 					 struct snd_ctl_elem_value *ucontrol)
11246 {
11247 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11248 	long *valp = ucontrol->value.integer.value;
11249 	int change;
11250 
11251 	change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11252 	if (change)
11253 		alc262_lenovo_3000_automute(codec, 0);
11254 	return change;
11255 }
11256 
11257 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11258 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11259 	{
11260 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11261 		.name = "Master Playback Switch",
11262 		.subdevice = HDA_SUBDEV_AMP_FLAG,
11263 		.info = snd_hda_mixer_amp_switch_info,
11264 		.get = snd_hda_mixer_amp_switch_get,
11265 		.put = alc262_lenovo_3000_master_sw_put,
11266 		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11267 	},
11268 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11269 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11270 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11271 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11272 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11273 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11274 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11275 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11276 	{ } /* end */
11277 };
11278 
11279 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11280 	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11281 	ALC262_HIPPO_MASTER_SWITCH,
11282 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11283 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11284 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11285 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11286 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11287 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11288 	{ } /* end */
11289 };
11290 
11291 /* additional init verbs for Benq laptops */
11292 static struct hda_verb alc262_EAPD_verbs[] = {
11293 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11294 	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11295 	{}
11296 };
11297 
11298 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11299 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11300 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11301 
11302 	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11303 	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11304 	{}
11305 };
11306 
11307 /* Samsung Q1 Ultra Vista model setup */
11308 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11309 	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11310 	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11311 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11312 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11313 	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11314 	HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11315 	{ } /* end */
11316 };
11317 
11318 static struct hda_verb alc262_ultra_verbs[] = {
11319 	/* output mixer */
11320 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11321 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11322 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11323 	/* speaker */
11324 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11325 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11326 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11327 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11328 	/* HP */
11329 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11330 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11331 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11332 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11333 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11334 	/* internal mic */
11335 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11336 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11337 	/* ADC, choose mic */
11338 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11339 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11340 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11341 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11342 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11343 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11344 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11345 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11346 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11347 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11348 	{}
11349 };
11350 
11351 /* mute/unmute internal speaker according to the hp jack and mute state */
11352 static void alc262_ultra_automute(struct hda_codec *codec)
11353 {
11354 	struct alc_spec *spec = codec->spec;
11355 	unsigned int mute;
11356 
11357 	mute = 0;
11358 	/* auto-mute only when HP is used as HP */
11359 	if (!spec->cur_mux[0]) {
11360 		spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11361 		if (spec->jack_present)
11362 			mute = HDA_AMP_MUTE;
11363 	}
11364 	/* mute/unmute internal speaker */
11365 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11366 				 HDA_AMP_MUTE, mute);
11367 	/* mute/unmute HP */
11368 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11369 				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11370 }
11371 
11372 /* unsolicited event for HP jack sensing */
11373 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11374 				       unsigned int res)
11375 {
11376 	if ((res >> 26) != ALC880_HP_EVENT)
11377 		return;
11378 	alc262_ultra_automute(codec);
11379 }
11380 
11381 static struct hda_input_mux alc262_ultra_capture_source = {
11382 	.num_items = 2,
11383 	.items = {
11384 		{ "Mic", 0x1 },
11385 		{ "Headphone", 0x7 },
11386 	},
11387 };
11388 
11389 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11390 				     struct snd_ctl_elem_value *ucontrol)
11391 {
11392 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11393 	struct alc_spec *spec = codec->spec;
11394 	int ret;
11395 
11396 	ret = alc_mux_enum_put(kcontrol, ucontrol);
11397 	if (!ret)
11398 		return 0;
11399 	/* reprogram the HP pin as mic or HP according to the input source */
11400 	snd_hda_codec_write_cache(codec, 0x15, 0,
11401 				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11402 				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11403 	alc262_ultra_automute(codec); /* mute/unmute HP */
11404 	return ret;
11405 }
11406 
11407 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11408 	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11409 	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11410 	{
11411 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11412 		.name = "Capture Source",
11413 		.info = alc_mux_enum_info,
11414 		.get = alc_mux_enum_get,
11415 		.put = alc262_ultra_mux_enum_put,
11416 	},
11417 	{
11418 		.iface = NID_MAPPING,
11419 		.name = "Capture Source",
11420 		.private_value = 0x15,
11421 	},
11422 	{ } /* end */
11423 };
11424 
11425 /* We use two mixers depending on the output pin; 0x16 is a mono output
11426  * and thus it's bound with a different mixer.
11427  * This function returns which mixer amp should be used.
11428  */
11429 static int alc262_check_volbit(hda_nid_t nid)
11430 {
11431 	if (!nid)
11432 		return 0;
11433 	else if (nid == 0x16)
11434 		return 2;
11435 	else
11436 		return 1;
11437 }
11438 
11439 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11440 				  const char *pfx, int *vbits)
11441 {
11442 	unsigned long val;
11443 	int vbit;
11444 
11445 	vbit = alc262_check_volbit(nid);
11446 	if (!vbit)
11447 		return 0;
11448 	if (*vbits & vbit) /* a volume control for this mixer already there */
11449 		return 0;
11450 	*vbits |= vbit;
11451 	if (vbit == 2)
11452 		val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11453 	else
11454 		val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11455 	return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11456 }
11457 
11458 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11459 				 const char *pfx)
11460 {
11461 	unsigned long val;
11462 
11463 	if (!nid)
11464 		return 0;
11465 	if (nid == 0x16)
11466 		val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11467 	else
11468 		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11469 	return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11470 }
11471 
11472 /* add playback controls from the parsed DAC table */
11473 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11474 					     const struct auto_pin_cfg *cfg)
11475 {
11476 	const char *pfx;
11477 	int vbits;
11478 	int err;
11479 
11480 	spec->multiout.num_dacs = 1;	/* only use one dac */
11481 	spec->multiout.dac_nids = spec->private_dac_nids;
11482 	spec->multiout.dac_nids[0] = 2;
11483 
11484 	if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11485 		pfx = "Master";
11486 	else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11487 		pfx = "Speaker";
11488 	else
11489 		pfx = "Front";
11490 	err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11491 	if (err < 0)
11492 		return err;
11493 	err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11494 	if (err < 0)
11495 		return err;
11496 	err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11497 	if (err < 0)
11498 		return err;
11499 
11500 	vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11501 		alc262_check_volbit(cfg->speaker_pins[0]) |
11502 		alc262_check_volbit(cfg->hp_pins[0]);
11503 	if (vbits == 1 || vbits == 2)
11504 		pfx = "Master"; /* only one mixer is used */
11505 	else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11506 		pfx = "Speaker";
11507 	else
11508 		pfx = "Front";
11509 	vbits = 0;
11510 	err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11511 	if (err < 0)
11512 		return err;
11513 	err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11514 				     &vbits);
11515 	if (err < 0)
11516 		return err;
11517 	err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11518 				     &vbits);
11519 	if (err < 0)
11520 		return err;
11521 	return 0;
11522 }
11523 
11524 #define alc262_auto_create_input_ctls \
11525 	alc882_auto_create_input_ctls
11526 
11527 /*
11528  * generic initialization of ADC, input mixers and output mixers
11529  */
11530 static struct hda_verb alc262_volume_init_verbs[] = {
11531 	/*
11532 	 * Unmute ADC0-2 and set the default input to mic-in
11533 	 */
11534 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11535 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11536 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11537 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11538 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11539 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11540 
11541 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11542 	 * mixer widget
11543 	 * Note: PASD motherboards uses the Line In 2 as the input for
11544 	 * front panel mic (mic 2)
11545 	 */
11546 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11547 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11548 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11549 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11550 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11551 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11552 
11553 	/*
11554 	 * Set up output mixers (0x0c - 0x0f)
11555 	 */
11556 	/* set vol=0 to output mixers */
11557 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11558 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11559 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11560 
11561 	/* set up input amps for analog loopback */
11562 	/* Amp Indices: DAC = 0, mixer = 1 */
11563 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11564 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11565 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11566 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11567 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11568 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11569 
11570 	/* FIXME: use matrix-type input source selection */
11571 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11572 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11573 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11574 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11575 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11576 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11577 	/* Input mixer2 */
11578 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11579 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11580 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11581 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11582 	/* Input mixer3 */
11583 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11584 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11585 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11586 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11587 
11588 	{ }
11589 };
11590 
11591 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11592 	/*
11593 	 * Unmute ADC0-2 and set the default input to mic-in
11594 	 */
11595 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11596 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11597 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11598 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11599 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11600 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11601 
11602 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11603 	 * mixer widget
11604 	 * Note: PASD motherboards uses the Line In 2 as the input for
11605 	 * front panel mic (mic 2)
11606 	 */
11607 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11608 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11609 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11610 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11611 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11612 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11613 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11614         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11615 
11616 	/*
11617 	 * Set up output mixers (0x0c - 0x0e)
11618 	 */
11619 	/* set vol=0 to output mixers */
11620 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11621 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11622 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11623 
11624 	/* set up input amps for analog loopback */
11625 	/* Amp Indices: DAC = 0, mixer = 1 */
11626 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11627 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11628 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11629 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11630 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11631 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11632 
11633 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11634 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11635 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11636 
11637 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11638 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11639 
11640 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11641 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11642 
11643 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11644 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11645         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11646 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11647 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11648 
11649 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11650 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11651         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11652 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11653 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11654 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11655 
11656 
11657 	/* FIXME: use matrix-type input source selection */
11658 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11659 	/* Input mixer1: only unmute Mic */
11660 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11661 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11662 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11663 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11664 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11665 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11666 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11667 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11668 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11669 	/* Input mixer2 */
11670 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11671 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11672 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11673 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11674 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11675 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11676 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11677 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11678 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11679 	/* Input mixer3 */
11680 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11681 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11682 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11683 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11684 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11685 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11686 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11687 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11688 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11689 
11690 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11691 
11692 	{ }
11693 };
11694 
11695 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11696 	/*
11697 	 * Unmute ADC0-2 and set the default input to mic-in
11698 	 */
11699 	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11700 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11701 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11702 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11703 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11704 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11705 
11706 	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11707 	 * mixer widget
11708 	 * Note: PASD motherboards uses the Line In 2 as the input for front
11709 	 * panel mic (mic 2)
11710 	 */
11711 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11712 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11713 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11714 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11715 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11716 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11717 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11718 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11719 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11720 	/*
11721 	 * Set up output mixers (0x0c - 0x0e)
11722 	 */
11723 	/* set vol=0 to output mixers */
11724 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11725 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11726 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11727 
11728 	/* set up input amps for analog loopback */
11729 	/* Amp Indices: DAC = 0, mixer = 1 */
11730 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11731 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11732 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11733 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11734 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11735 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11736 
11737 
11738 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
11739 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
11740 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
11741 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
11742 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
11743 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
11744 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
11745 
11746 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11747 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11748 
11749 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11750 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11751 
11752 	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11753 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11754 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11755 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11756 	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11757 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11758 
11759 	/* FIXME: use matrix-type input source selection */
11760 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11761 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11762 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11763 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11764 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11765 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11766 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11767         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11768 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11769 	/* Input mixer2 */
11770 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11771 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11772 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11773 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11774 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11775         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11776 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11777 	/* Input mixer3 */
11778 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11779 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11780 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11781 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11782 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11783         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11784 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11785 
11786 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11787 
11788 	{ }
11789 };
11790 
11791 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11792 
11793 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
11794 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11795 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11796 
11797 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
11798 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
11799 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11800 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11801 
11802 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
11803 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11804 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11805 	{}
11806 };
11807 
11808 
11809 #ifdef CONFIG_SND_HDA_POWER_SAVE
11810 #define alc262_loopbacks	alc880_loopbacks
11811 #endif
11812 
11813 /* pcm configuration: identical with ALC880 */
11814 #define alc262_pcm_analog_playback	alc880_pcm_analog_playback
11815 #define alc262_pcm_analog_capture	alc880_pcm_analog_capture
11816 #define alc262_pcm_digital_playback	alc880_pcm_digital_playback
11817 #define alc262_pcm_digital_capture	alc880_pcm_digital_capture
11818 
11819 /*
11820  * BIOS auto configuration
11821  */
11822 static int alc262_parse_auto_config(struct hda_codec *codec)
11823 {
11824 	struct alc_spec *spec = codec->spec;
11825 	int err;
11826 	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11827 
11828 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11829 					   alc262_ignore);
11830 	if (err < 0)
11831 		return err;
11832 	if (!spec->autocfg.line_outs) {
11833 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11834 			spec->multiout.max_channels = 2;
11835 			spec->no_analog = 1;
11836 			goto dig_only;
11837 		}
11838 		return 0; /* can't find valid BIOS pin config */
11839 	}
11840 	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11841 	if (err < 0)
11842 		return err;
11843 	err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11844 	if (err < 0)
11845 		return err;
11846 
11847 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11848 
11849  dig_only:
11850 	if (spec->autocfg.dig_outs) {
11851 		spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11852 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
11853 	}
11854 	if (spec->autocfg.dig_in_pin)
11855 		spec->dig_in_nid = ALC262_DIGIN_NID;
11856 
11857 	if (spec->kctls.list)
11858 		add_mixer(spec, spec->kctls.list);
11859 
11860 	add_verb(spec, alc262_volume_init_verbs);
11861 	spec->num_mux_defs = 1;
11862 	spec->input_mux = &spec->private_imux[0];
11863 
11864 	err = alc_auto_add_mic_boost(codec);
11865 	if (err < 0)
11866 		return err;
11867 
11868 	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11869 
11870 	return 1;
11871 }
11872 
11873 #define alc262_auto_init_multi_out	alc882_auto_init_multi_out
11874 #define alc262_auto_init_hp_out		alc882_auto_init_hp_out
11875 #define alc262_auto_init_analog_input	alc882_auto_init_analog_input
11876 #define alc262_auto_init_input_src	alc882_auto_init_input_src
11877 
11878 
11879 /* init callback for auto-configuration model -- overriding the default init */
11880 static void alc262_auto_init(struct hda_codec *codec)
11881 {
11882 	struct alc_spec *spec = codec->spec;
11883 	alc262_auto_init_multi_out(codec);
11884 	alc262_auto_init_hp_out(codec);
11885 	alc262_auto_init_analog_input(codec);
11886 	alc262_auto_init_input_src(codec);
11887 	if (spec->unsol_event)
11888 		alc_inithook(codec);
11889 }
11890 
11891 /*
11892  * configuration and preset
11893  */
11894 static const char *alc262_models[ALC262_MODEL_LAST] = {
11895 	[ALC262_BASIC]		= "basic",
11896 	[ALC262_HIPPO]		= "hippo",
11897 	[ALC262_HIPPO_1]	= "hippo_1",
11898 	[ALC262_FUJITSU]	= "fujitsu",
11899 	[ALC262_HP_BPC]		= "hp-bpc",
11900 	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11901 	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
11902 	[ALC262_HP_RP5700]	= "hp-rp5700",
11903 	[ALC262_BENQ_ED8]	= "benq",
11904 	[ALC262_BENQ_T31]	= "benq-t31",
11905 	[ALC262_SONY_ASSAMD]	= "sony-assamd",
11906 	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
11907 	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
11908 	[ALC262_ULTRA]		= "ultra",
11909 	[ALC262_LENOVO_3000]	= "lenovo-3000",
11910 	[ALC262_NEC]		= "nec",
11911 	[ALC262_TYAN]		= "tyan",
11912 	[ALC262_AUTO]		= "auto",
11913 };
11914 
11915 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11916 	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11917 	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11918 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11919 			   ALC262_HP_BPC),
11920 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11921 			   ALC262_HP_BPC),
11922 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11923 			   ALC262_HP_BPC),
11924 	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11925 	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11926 	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11927 	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11928 	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11929 	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11930 	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11931 	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11932 	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11933 	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11934 	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11935 	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11936 		      ALC262_HP_TC_T5735),
11937 	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11938 	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11939 	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11940 	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11941 	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11942 	SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11943 	SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11944 	SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11945 #if 0 /* disable the quirk since model=auto works better in recent versions */
11946 	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11947 			   ALC262_SONY_ASSAMD),
11948 #endif
11949 	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11950 		      ALC262_TOSHIBA_RX1),
11951 	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11952 	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11953 	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11954 	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11955 	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11956 			   ALC262_ULTRA),
11957 	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11958 	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11959 	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11960 	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11961 	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11962 	{}
11963 };
11964 
11965 static struct alc_config_preset alc262_presets[] = {
11966 	[ALC262_BASIC] = {
11967 		.mixers = { alc262_base_mixer },
11968 		.init_verbs = { alc262_init_verbs },
11969 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11970 		.dac_nids = alc262_dac_nids,
11971 		.hp_nid = 0x03,
11972 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11973 		.channel_mode = alc262_modes,
11974 		.input_mux = &alc262_capture_source,
11975 	},
11976 	[ALC262_HIPPO] = {
11977 		.mixers = { alc262_hippo_mixer },
11978 		.init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11979 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11980 		.dac_nids = alc262_dac_nids,
11981 		.hp_nid = 0x03,
11982 		.dig_out_nid = ALC262_DIGOUT_NID,
11983 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11984 		.channel_mode = alc262_modes,
11985 		.input_mux = &alc262_capture_source,
11986 		.unsol_event = alc262_hippo_unsol_event,
11987 		.setup = alc262_hippo_setup,
11988 		.init_hook = alc262_hippo_automute,
11989 	},
11990 	[ALC262_HIPPO_1] = {
11991 		.mixers = { alc262_hippo1_mixer },
11992 		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11993 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
11994 		.dac_nids = alc262_dac_nids,
11995 		.hp_nid = 0x02,
11996 		.dig_out_nid = ALC262_DIGOUT_NID,
11997 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
11998 		.channel_mode = alc262_modes,
11999 		.input_mux = &alc262_capture_source,
12000 		.unsol_event = alc262_hippo_unsol_event,
12001 		.setup = alc262_hippo1_setup,
12002 		.init_hook = alc262_hippo_automute,
12003 	},
12004 	[ALC262_FUJITSU] = {
12005 		.mixers = { alc262_fujitsu_mixer },
12006 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12007 				alc262_fujitsu_unsol_verbs },
12008 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12009 		.dac_nids = alc262_dac_nids,
12010 		.hp_nid = 0x03,
12011 		.dig_out_nid = ALC262_DIGOUT_NID,
12012 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12013 		.channel_mode = alc262_modes,
12014 		.input_mux = &alc262_fujitsu_capture_source,
12015 		.unsol_event = alc262_fujitsu_unsol_event,
12016 		.init_hook = alc262_fujitsu_init_hook,
12017 	},
12018 	[ALC262_HP_BPC] = {
12019 		.mixers = { alc262_HP_BPC_mixer },
12020 		.init_verbs = { alc262_HP_BPC_init_verbs },
12021 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12022 		.dac_nids = alc262_dac_nids,
12023 		.hp_nid = 0x03,
12024 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12025 		.channel_mode = alc262_modes,
12026 		.input_mux = &alc262_HP_capture_source,
12027 		.unsol_event = alc262_hp_bpc_unsol_event,
12028 		.init_hook = alc262_hp_bpc_automute,
12029 	},
12030 	[ALC262_HP_BPC_D7000_WF] = {
12031 		.mixers = { alc262_HP_BPC_WildWest_mixer },
12032 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12033 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12034 		.dac_nids = alc262_dac_nids,
12035 		.hp_nid = 0x03,
12036 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12037 		.channel_mode = alc262_modes,
12038 		.input_mux = &alc262_HP_D7000_capture_source,
12039 		.unsol_event = alc262_hp_wildwest_unsol_event,
12040 		.init_hook = alc262_hp_wildwest_automute,
12041 	},
12042 	[ALC262_HP_BPC_D7000_WL] = {
12043 		.mixers = { alc262_HP_BPC_WildWest_mixer,
12044 			    alc262_HP_BPC_WildWest_option_mixer },
12045 		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12046 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12047 		.dac_nids = alc262_dac_nids,
12048 		.hp_nid = 0x03,
12049 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12050 		.channel_mode = alc262_modes,
12051 		.input_mux = &alc262_HP_D7000_capture_source,
12052 		.unsol_event = alc262_hp_wildwest_unsol_event,
12053 		.init_hook = alc262_hp_wildwest_automute,
12054 	},
12055 	[ALC262_HP_TC_T5735] = {
12056 		.mixers = { alc262_hp_t5735_mixer },
12057 		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12058 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12059 		.dac_nids = alc262_dac_nids,
12060 		.hp_nid = 0x03,
12061 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12062 		.channel_mode = alc262_modes,
12063 		.input_mux = &alc262_capture_source,
12064 		.unsol_event = alc_sku_unsol_event,
12065 		.setup = alc262_hp_t5735_setup,
12066 		.init_hook = alc_inithook,
12067 	},
12068 	[ALC262_HP_RP5700] = {
12069 		.mixers = { alc262_hp_rp5700_mixer },
12070 		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12071 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12072 		.dac_nids = alc262_dac_nids,
12073 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12074 		.channel_mode = alc262_modes,
12075 		.input_mux = &alc262_hp_rp5700_capture_source,
12076         },
12077 	[ALC262_BENQ_ED8] = {
12078 		.mixers = { alc262_base_mixer },
12079 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12080 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12081 		.dac_nids = alc262_dac_nids,
12082 		.hp_nid = 0x03,
12083 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12084 		.channel_mode = alc262_modes,
12085 		.input_mux = &alc262_capture_source,
12086 	},
12087 	[ALC262_SONY_ASSAMD] = {
12088 		.mixers = { alc262_sony_mixer },
12089 		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12090 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12091 		.dac_nids = alc262_dac_nids,
12092 		.hp_nid = 0x02,
12093 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12094 		.channel_mode = alc262_modes,
12095 		.input_mux = &alc262_capture_source,
12096 		.unsol_event = alc262_hippo_unsol_event,
12097 		.setup = alc262_hippo_setup,
12098 		.init_hook = alc262_hippo_automute,
12099 	},
12100 	[ALC262_BENQ_T31] = {
12101 		.mixers = { alc262_benq_t31_mixer },
12102 		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12103 				alc_hp15_unsol_verbs },
12104 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12105 		.dac_nids = alc262_dac_nids,
12106 		.hp_nid = 0x03,
12107 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12108 		.channel_mode = alc262_modes,
12109 		.input_mux = &alc262_capture_source,
12110 		.unsol_event = alc262_hippo_unsol_event,
12111 		.setup = alc262_hippo_setup,
12112 		.init_hook = alc262_hippo_automute,
12113 	},
12114 	[ALC262_ULTRA] = {
12115 		.mixers = { alc262_ultra_mixer },
12116 		.cap_mixer = alc262_ultra_capture_mixer,
12117 		.init_verbs = { alc262_ultra_verbs },
12118 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12119 		.dac_nids = alc262_dac_nids,
12120 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12121 		.channel_mode = alc262_modes,
12122 		.input_mux = &alc262_ultra_capture_source,
12123 		.adc_nids = alc262_adc_nids, /* ADC0 */
12124 		.capsrc_nids = alc262_capsrc_nids,
12125 		.num_adc_nids = 1, /* single ADC */
12126 		.unsol_event = alc262_ultra_unsol_event,
12127 		.init_hook = alc262_ultra_automute,
12128 	},
12129 	[ALC262_LENOVO_3000] = {
12130 		.mixers = { alc262_lenovo_3000_mixer },
12131 		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12132 				alc262_lenovo_3000_unsol_verbs,
12133 				alc262_lenovo_3000_init_verbs },
12134 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12135 		.dac_nids = alc262_dac_nids,
12136 		.hp_nid = 0x03,
12137 		.dig_out_nid = ALC262_DIGOUT_NID,
12138 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12139 		.channel_mode = alc262_modes,
12140 		.input_mux = &alc262_fujitsu_capture_source,
12141 		.unsol_event = alc262_lenovo_3000_unsol_event,
12142 	},
12143 	[ALC262_NEC] = {
12144 		.mixers = { alc262_nec_mixer },
12145 		.init_verbs = { alc262_nec_verbs },
12146 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12147 		.dac_nids = alc262_dac_nids,
12148 		.hp_nid = 0x03,
12149 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12150 		.channel_mode = alc262_modes,
12151 		.input_mux = &alc262_capture_source,
12152 	},
12153 	[ALC262_TOSHIBA_S06] = {
12154 		.mixers = { alc262_toshiba_s06_mixer },
12155 		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12156 							alc262_eapd_verbs },
12157 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12158 		.capsrc_nids = alc262_dmic_capsrc_nids,
12159 		.dac_nids = alc262_dac_nids,
12160 		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12161 		.num_adc_nids = 1, /* single ADC */
12162 		.dig_out_nid = ALC262_DIGOUT_NID,
12163 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12164 		.channel_mode = alc262_modes,
12165 		.unsol_event = alc_sku_unsol_event,
12166 		.setup = alc262_toshiba_s06_setup,
12167 		.init_hook = alc_inithook,
12168 	},
12169 	[ALC262_TOSHIBA_RX1] = {
12170 		.mixers = { alc262_toshiba_rx1_mixer },
12171 		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12172 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12173 		.dac_nids = alc262_dac_nids,
12174 		.hp_nid = 0x03,
12175 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12176 		.channel_mode = alc262_modes,
12177 		.input_mux = &alc262_capture_source,
12178 		.unsol_event = alc262_hippo_unsol_event,
12179 		.setup = alc262_hippo_setup,
12180 		.init_hook = alc262_hippo_automute,
12181 	},
12182 	[ALC262_TYAN] = {
12183 		.mixers = { alc262_tyan_mixer },
12184 		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12185 		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12186 		.dac_nids = alc262_dac_nids,
12187 		.hp_nid = 0x02,
12188 		.dig_out_nid = ALC262_DIGOUT_NID,
12189 		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12190 		.channel_mode = alc262_modes,
12191 		.input_mux = &alc262_capture_source,
12192 		.unsol_event = alc_automute_amp_unsol_event,
12193 		.setup = alc262_tyan_setup,
12194 		.init_hook = alc_automute_amp,
12195 	},
12196 };
12197 
12198 static int patch_alc262(struct hda_codec *codec)
12199 {
12200 	struct alc_spec *spec;
12201 	int board_config;
12202 	int err;
12203 
12204 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12205 	if (spec == NULL)
12206 		return -ENOMEM;
12207 
12208 	codec->spec = spec;
12209 #if 0
12210 	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12211 	 * under-run
12212 	 */
12213 	{
12214 	int tmp;
12215 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12216 	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12217 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12218 	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12219 	}
12220 #endif
12221 
12222 	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12223 
12224 	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12225 						  alc262_models,
12226 						  alc262_cfg_tbl);
12227 
12228 	if (board_config < 0) {
12229 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12230 		       codec->chip_name);
12231 		board_config = ALC262_AUTO;
12232 	}
12233 
12234 	if (board_config == ALC262_AUTO) {
12235 		/* automatic parse from the BIOS config */
12236 		err = alc262_parse_auto_config(codec);
12237 		if (err < 0) {
12238 			alc_free(codec);
12239 			return err;
12240 		} else if (!err) {
12241 			printk(KERN_INFO
12242 			       "hda_codec: Cannot set up configuration "
12243 			       "from BIOS.  Using base mode...\n");
12244 			board_config = ALC262_BASIC;
12245 		}
12246 	}
12247 
12248 	if (!spec->no_analog) {
12249 		err = snd_hda_attach_beep_device(codec, 0x1);
12250 		if (err < 0) {
12251 			alc_free(codec);
12252 			return err;
12253 		}
12254 	}
12255 
12256 	if (board_config != ALC262_AUTO)
12257 		setup_preset(codec, &alc262_presets[board_config]);
12258 
12259 	spec->stream_analog_playback = &alc262_pcm_analog_playback;
12260 	spec->stream_analog_capture = &alc262_pcm_analog_capture;
12261 
12262 	spec->stream_digital_playback = &alc262_pcm_digital_playback;
12263 	spec->stream_digital_capture = &alc262_pcm_digital_capture;
12264 
12265 	if (!spec->adc_nids && spec->input_mux) {
12266 		int i;
12267 		/* check whether the digital-mic has to be supported */
12268 		for (i = 0; i < spec->input_mux->num_items; i++) {
12269 			if (spec->input_mux->items[i].index >= 9)
12270 				break;
12271 		}
12272 		if (i < spec->input_mux->num_items) {
12273 			/* use only ADC0 */
12274 			spec->adc_nids = alc262_dmic_adc_nids;
12275 			spec->num_adc_nids = 1;
12276 			spec->capsrc_nids = alc262_dmic_capsrc_nids;
12277 		} else {
12278 			/* all analog inputs */
12279 			/* check whether NID 0x07 is valid */
12280 			unsigned int wcap = get_wcaps(codec, 0x07);
12281 
12282 			/* get type */
12283 			wcap = get_wcaps_type(wcap);
12284 			if (wcap != AC_WID_AUD_IN) {
12285 				spec->adc_nids = alc262_adc_nids_alt;
12286 				spec->num_adc_nids =
12287 					ARRAY_SIZE(alc262_adc_nids_alt);
12288 				spec->capsrc_nids = alc262_capsrc_nids_alt;
12289 			} else {
12290 				spec->adc_nids = alc262_adc_nids;
12291 				spec->num_adc_nids =
12292 					ARRAY_SIZE(alc262_adc_nids);
12293 				spec->capsrc_nids = alc262_capsrc_nids;
12294 			}
12295 		}
12296 	}
12297 	if (!spec->cap_mixer && !spec->no_analog)
12298 		set_capture_mixer(codec);
12299 	if (!spec->no_analog)
12300 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12301 
12302 	spec->vmaster_nid = 0x0c;
12303 
12304 	codec->patch_ops = alc_patch_ops;
12305 	if (board_config == ALC262_AUTO)
12306 		spec->init_hook = alc262_auto_init;
12307 #ifdef CONFIG_SND_HDA_POWER_SAVE
12308 	if (!spec->loopback.amplist)
12309 		spec->loopback.amplist = alc262_loopbacks;
12310 #endif
12311 
12312 	return 0;
12313 }
12314 
12315 /*
12316  *  ALC268 channel source setting (2 channel)
12317  */
12318 #define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
12319 #define alc268_modes		alc260_modes
12320 
12321 static hda_nid_t alc268_dac_nids[2] = {
12322 	/* front, hp */
12323 	0x02, 0x03
12324 };
12325 
12326 static hda_nid_t alc268_adc_nids[2] = {
12327 	/* ADC0-1 */
12328 	0x08, 0x07
12329 };
12330 
12331 static hda_nid_t alc268_adc_nids_alt[1] = {
12332 	/* ADC0 */
12333 	0x08
12334 };
12335 
12336 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12337 
12338 static struct snd_kcontrol_new alc268_base_mixer[] = {
12339 	/* output mixer control */
12340 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12341 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12342 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12343 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12344 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12345 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12346 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12347 	{ }
12348 };
12349 
12350 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12351 	/* output mixer control */
12352 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12353 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12354 	ALC262_HIPPO_MASTER_SWITCH,
12355 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12356 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12357 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12358 	{ }
12359 };
12360 
12361 /* bind Beep switches of both NID 0x0f and 0x10 */
12362 static struct hda_bind_ctls alc268_bind_beep_sw = {
12363 	.ops = &snd_hda_bind_sw,
12364 	.values = {
12365 		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12366 		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12367 		0
12368 	},
12369 };
12370 
12371 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12372 	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12373 	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12374 	{ }
12375 };
12376 
12377 static struct hda_verb alc268_eapd_verbs[] = {
12378 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12379 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12380 	{ }
12381 };
12382 
12383 /* Toshiba specific */
12384 static struct hda_verb alc268_toshiba_verbs[] = {
12385 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12386 	{ } /* end */
12387 };
12388 
12389 /* Acer specific */
12390 /* bind volumes of both NID 0x02 and 0x03 */
12391 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12392 	.ops = &snd_hda_bind_vol,
12393 	.values = {
12394 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12395 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12396 		0
12397 	},
12398 };
12399 
12400 /* mute/unmute internal speaker according to the hp jack and mute state */
12401 static void alc268_acer_automute(struct hda_codec *codec, int force)
12402 {
12403 	struct alc_spec *spec = codec->spec;
12404 	unsigned int mute;
12405 
12406 	if (force || !spec->sense_updated) {
12407 		spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12408 		spec->sense_updated = 1;
12409 	}
12410 	if (spec->jack_present)
12411 		mute = HDA_AMP_MUTE; /* mute internal speaker */
12412 	else /* unmute internal speaker if necessary */
12413 		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12414 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12415 				 HDA_AMP_MUTE, mute);
12416 }
12417 
12418 
12419 /* bind hp and internal speaker mute (with plug check) */
12420 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12421 				     struct snd_ctl_elem_value *ucontrol)
12422 {
12423 	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12424 	long *valp = ucontrol->value.integer.value;
12425 	int change;
12426 
12427 	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12428 	if (change)
12429 		alc268_acer_automute(codec, 0);
12430 	return change;
12431 }
12432 
12433 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12434 	/* output mixer control */
12435 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12436 	{
12437 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12438 		.name = "Master Playback Switch",
12439 		.subdevice = HDA_SUBDEV_AMP_FLAG,
12440 		.info = snd_hda_mixer_amp_switch_info,
12441 		.get = snd_hda_mixer_amp_switch_get,
12442 		.put = alc268_acer_master_sw_put,
12443 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12444 	},
12445 	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12446 	{ }
12447 };
12448 
12449 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12450 	/* output mixer control */
12451 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12452 	{
12453 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12454 		.name = "Master Playback Switch",
12455 		.subdevice = HDA_SUBDEV_AMP_FLAG,
12456 		.info = snd_hda_mixer_amp_switch_info,
12457 		.get = snd_hda_mixer_amp_switch_get,
12458 		.put = alc268_acer_master_sw_put,
12459 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12460 	},
12461 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12462 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12463 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12464 	{ }
12465 };
12466 
12467 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12468 	/* output mixer control */
12469 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12470 	{
12471 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12472 		.name = "Master Playback Switch",
12473 		.subdevice = HDA_SUBDEV_AMP_FLAG,
12474 		.info = snd_hda_mixer_amp_switch_info,
12475 		.get = snd_hda_mixer_amp_switch_get,
12476 		.put = alc268_acer_master_sw_put,
12477 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12478 	},
12479 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12480 	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12481 	{ }
12482 };
12483 
12484 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12485 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12486 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12487 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12488 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12489 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12490 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12491 	{ }
12492 };
12493 
12494 static struct hda_verb alc268_acer_verbs[] = {
12495 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12496 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12497 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12498 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12499 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12500 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12501 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12502 	{ }
12503 };
12504 
12505 /* unsolicited event for HP jack sensing */
12506 #define alc268_toshiba_unsol_event	alc262_hippo_unsol_event
12507 #define alc268_toshiba_setup		alc262_hippo_setup
12508 #define alc268_toshiba_automute		alc262_hippo_automute
12509 
12510 static void alc268_acer_unsol_event(struct hda_codec *codec,
12511 				       unsigned int res)
12512 {
12513 	if ((res >> 26) != ALC880_HP_EVENT)
12514 		return;
12515 	alc268_acer_automute(codec, 1);
12516 }
12517 
12518 static void alc268_acer_init_hook(struct hda_codec *codec)
12519 {
12520 	alc268_acer_automute(codec, 1);
12521 }
12522 
12523 /* toggle speaker-output according to the hp-jack state */
12524 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12525 {
12526 	unsigned int present;
12527 	unsigned char bits;
12528 
12529 	present = snd_hda_jack_detect(codec, 0x15);
12530 	bits = present ? HDA_AMP_MUTE : 0;
12531 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12532 				 HDA_AMP_MUTE, bits);
12533 	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12534 				 HDA_AMP_MUTE, bits);
12535 }
12536 
12537 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12538 				    unsigned int res)
12539 {
12540 	switch (res >> 26) {
12541 	case ALC880_HP_EVENT:
12542 		alc268_aspire_one_speaker_automute(codec);
12543 		break;
12544 	case ALC880_MIC_EVENT:
12545 		alc_mic_automute(codec);
12546 		break;
12547 	}
12548 }
12549 
12550 static void alc268_acer_lc_setup(struct hda_codec *codec)
12551 {
12552 	struct alc_spec *spec = codec->spec;
12553 	spec->ext_mic.pin = 0x18;
12554 	spec->ext_mic.mux_idx = 0;
12555 	spec->int_mic.pin = 0x12;
12556 	spec->int_mic.mux_idx = 6;
12557 	spec->auto_mic = 1;
12558 }
12559 
12560 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12561 {
12562 	alc268_aspire_one_speaker_automute(codec);
12563 	alc_mic_automute(codec);
12564 }
12565 
12566 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12567 	/* output mixer control */
12568 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12569 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12570 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12571 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12572 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12573 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12574 	{ }
12575 };
12576 
12577 static struct hda_verb alc268_dell_verbs[] = {
12578 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12579 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12580 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12581 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12582 	{ }
12583 };
12584 
12585 /* mute/unmute internal speaker according to the hp jack and mute state */
12586 static void alc268_dell_setup(struct hda_codec *codec)
12587 {
12588 	struct alc_spec *spec = codec->spec;
12589 
12590 	spec->autocfg.hp_pins[0] = 0x15;
12591 	spec->autocfg.speaker_pins[0] = 0x14;
12592 	spec->ext_mic.pin = 0x18;
12593 	spec->ext_mic.mux_idx = 0;
12594 	spec->int_mic.pin = 0x19;
12595 	spec->int_mic.mux_idx = 1;
12596 	spec->auto_mic = 1;
12597 }
12598 
12599 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12600 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12601 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12602 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12603 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12604 	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12605 	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12606 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12607 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12608 	{ }
12609 };
12610 
12611 static struct hda_verb alc267_quanta_il1_verbs[] = {
12612 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12613 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12614 	{ }
12615 };
12616 
12617 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12618 {
12619 	struct alc_spec *spec = codec->spec;
12620 	spec->autocfg.hp_pins[0] = 0x15;
12621 	spec->autocfg.speaker_pins[0] = 0x14;
12622 	spec->ext_mic.pin = 0x18;
12623 	spec->ext_mic.mux_idx = 0;
12624 	spec->int_mic.pin = 0x19;
12625 	spec->int_mic.mux_idx = 1;
12626 	spec->auto_mic = 1;
12627 }
12628 
12629 /*
12630  * generic initialization of ADC, input mixers and output mixers
12631  */
12632 static struct hda_verb alc268_base_init_verbs[] = {
12633 	/* Unmute DAC0-1 and set vol = 0 */
12634 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12635 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12636 
12637 	/*
12638 	 * Set up output mixers (0x0c - 0x0e)
12639 	 */
12640 	/* set vol=0 to output mixers */
12641 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12642         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12643 
12644 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12645 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12646 
12647 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12648 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12649 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12650 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12651 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12652 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12653 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12654 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12655 
12656 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12657 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12658 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12659 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12660 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12661 
12662 	/* set PCBEEP vol = 0, mute connections */
12663 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12664 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12665 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12666 
12667 	/* Unmute Selector 23h,24h and set the default input to mic-in */
12668 
12669 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12670 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12671 	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12672 	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12673 
12674 	{ }
12675 };
12676 
12677 /*
12678  * generic initialization of ADC, input mixers and output mixers
12679  */
12680 static struct hda_verb alc268_volume_init_verbs[] = {
12681 	/* set output DAC */
12682 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12683 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12684 
12685 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12686 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12687 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12688 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12689 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12690 
12691 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12692 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12693 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12694 
12695 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12696 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12697 
12698 	/* set PCBEEP vol = 0, mute connections */
12699 	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12700 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12701 	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12702 
12703 	{ }
12704 };
12705 
12706 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12707 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12708 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12709 	{ } /* end */
12710 };
12711 
12712 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12713 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12714 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12715 	_DEFINE_CAPSRC(1),
12716 	{ } /* end */
12717 };
12718 
12719 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12720 	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12721 	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12722 	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12723 	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12724 	_DEFINE_CAPSRC(2),
12725 	{ } /* end */
12726 };
12727 
12728 static struct hda_input_mux alc268_capture_source = {
12729 	.num_items = 4,
12730 	.items = {
12731 		{ "Mic", 0x0 },
12732 		{ "Front Mic", 0x1 },
12733 		{ "Line", 0x2 },
12734 		{ "CD", 0x3 },
12735 	},
12736 };
12737 
12738 static struct hda_input_mux alc268_acer_capture_source = {
12739 	.num_items = 3,
12740 	.items = {
12741 		{ "Mic", 0x0 },
12742 		{ "Internal Mic", 0x1 },
12743 		{ "Line", 0x2 },
12744 	},
12745 };
12746 
12747 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12748 	.num_items = 3,
12749 	.items = {
12750 		{ "Mic", 0x0 },
12751 		{ "Internal Mic", 0x6 },
12752 		{ "Line", 0x2 },
12753 	},
12754 };
12755 
12756 #ifdef CONFIG_SND_DEBUG
12757 static struct snd_kcontrol_new alc268_test_mixer[] = {
12758 	/* Volume widgets */
12759 	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12760 	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12761 	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12762 	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12763 	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12764 	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12765 	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12766 	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12767 	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12768 	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12769 	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12770 	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12771 	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12772 	/* The below appears problematic on some hardwares */
12773 	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12774 	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12775 	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12776 	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12777 	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12778 
12779 	/* Modes for retasking pin widgets */
12780 	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12781 	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12782 	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12783 	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12784 
12785 	/* Controls for GPIO pins, assuming they are configured as outputs */
12786 	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12787 	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12788 	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12789 	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12790 
12791 	/* Switches to allow the digital SPDIF output pin to be enabled.
12792 	 * The ALC268 does not have an SPDIF input.
12793 	 */
12794 	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12795 
12796 	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
12797 	 * this output to turn on an external amplifier.
12798 	 */
12799 	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12800 	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12801 
12802 	{ } /* end */
12803 };
12804 #endif
12805 
12806 /* create input playback/capture controls for the given pin */
12807 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12808 				    const char *ctlname, int idx)
12809 {
12810 	hda_nid_t dac;
12811 	int err;
12812 
12813 	switch (nid) {
12814 	case 0x14:
12815 	case 0x16:
12816 		dac = 0x02;
12817 		break;
12818 	case 0x15:
12819 		dac = 0x03;
12820 		break;
12821 	default:
12822 		return 0;
12823 	}
12824 	if (spec->multiout.dac_nids[0] != dac &&
12825 	    spec->multiout.dac_nids[1] != dac) {
12826 		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12827 				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12828 						      HDA_OUTPUT));
12829 		if (err < 0)
12830 			return err;
12831 		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12832 	}
12833 
12834 	if (nid != 0x16)
12835 		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12836 			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12837 	else /* mono */
12838 		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12839 			  HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12840 	if (err < 0)
12841 		return err;
12842 	return 0;
12843 }
12844 
12845 /* add playback controls from the parsed DAC table */
12846 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12847 					     const struct auto_pin_cfg *cfg)
12848 {
12849 	hda_nid_t nid;
12850 	int err;
12851 
12852 	spec->multiout.dac_nids = spec->private_dac_nids;
12853 
12854 	nid = cfg->line_out_pins[0];
12855 	if (nid) {
12856 		const char *name;
12857 		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12858 			name = "Speaker";
12859 		else
12860 			name = "Front";
12861 		err = alc268_new_analog_output(spec, nid, name, 0);
12862 		if (err < 0)
12863 			return err;
12864 	}
12865 
12866 	nid = cfg->speaker_pins[0];
12867 	if (nid == 0x1d) {
12868 		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12869 				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12870 		if (err < 0)
12871 			return err;
12872 	} else {
12873 		err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12874 		if (err < 0)
12875 			return err;
12876 	}
12877 	nid = cfg->hp_pins[0];
12878 	if (nid) {
12879 		err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12880 		if (err < 0)
12881 			return err;
12882 	}
12883 
12884 	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12885 	if (nid == 0x16) {
12886 		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12887 				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12888 		if (err < 0)
12889 			return err;
12890 	}
12891 	return 0;
12892 }
12893 
12894 /* create playback/capture controls for input pins */
12895 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12896 						const struct auto_pin_cfg *cfg)
12897 {
12898 	return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12899 }
12900 
12901 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12902 					      hda_nid_t nid, int pin_type)
12903 {
12904 	int idx;
12905 
12906 	alc_set_pin_output(codec, nid, pin_type);
12907 	if (nid == 0x14 || nid == 0x16)
12908 		idx = 0;
12909 	else
12910 		idx = 1;
12911 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12912 }
12913 
12914 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12915 {
12916 	struct alc_spec *spec = codec->spec;
12917 	hda_nid_t nid = spec->autocfg.line_out_pins[0];
12918 	if (nid) {
12919 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
12920 		alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12921 	}
12922 }
12923 
12924 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12925 {
12926 	struct alc_spec *spec = codec->spec;
12927 	hda_nid_t pin;
12928 
12929 	pin = spec->autocfg.hp_pins[0];
12930 	if (pin)
12931 		alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12932 	pin = spec->autocfg.speaker_pins[0];
12933 	if (pin)
12934 		alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12935 }
12936 
12937 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12938 {
12939 	struct alc_spec *spec = codec->spec;
12940 	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12941 	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12942 	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12943 	unsigned int	dac_vol1, dac_vol2;
12944 
12945 	if (line_nid == 0x1d || speaker_nid == 0x1d) {
12946 		snd_hda_codec_write(codec, speaker_nid, 0,
12947 				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12948 		/* mute mixer inputs from 0x1d */
12949 		snd_hda_codec_write(codec, 0x0f, 0,
12950 				    AC_VERB_SET_AMP_GAIN_MUTE,
12951 				    AMP_IN_UNMUTE(1));
12952 		snd_hda_codec_write(codec, 0x10, 0,
12953 				    AC_VERB_SET_AMP_GAIN_MUTE,
12954 				    AMP_IN_UNMUTE(1));
12955 	} else {
12956 		/* unmute mixer inputs from 0x1d */
12957 		snd_hda_codec_write(codec, 0x0f, 0,
12958 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12959 		snd_hda_codec_write(codec, 0x10, 0,
12960 				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12961 	}
12962 
12963 	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
12964 	if (line_nid == 0x14)
12965 		dac_vol2 = AMP_OUT_ZERO;
12966 	else if (line_nid == 0x15)
12967 		dac_vol1 = AMP_OUT_ZERO;
12968 	if (hp_nid == 0x14)
12969 		dac_vol2 = AMP_OUT_ZERO;
12970 	else if (hp_nid == 0x15)
12971 		dac_vol1 = AMP_OUT_ZERO;
12972 	if (line_nid != 0x16 || hp_nid != 0x16 ||
12973 	    spec->autocfg.line_out_pins[1] != 0x16 ||
12974 	    spec->autocfg.line_out_pins[2] != 0x16)
12975 		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12976 
12977 	snd_hda_codec_write(codec, 0x02, 0,
12978 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12979 	snd_hda_codec_write(codec, 0x03, 0,
12980 			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12981 }
12982 
12983 /* pcm configuration: identical with ALC880 */
12984 #define alc268_pcm_analog_playback	alc880_pcm_analog_playback
12985 #define alc268_pcm_analog_capture	alc880_pcm_analog_capture
12986 #define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
12987 #define alc268_pcm_digital_playback	alc880_pcm_digital_playback
12988 
12989 /*
12990  * BIOS auto configuration
12991  */
12992 static int alc268_parse_auto_config(struct hda_codec *codec)
12993 {
12994 	struct alc_spec *spec = codec->spec;
12995 	int err;
12996 	static hda_nid_t alc268_ignore[] = { 0 };
12997 
12998 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12999 					   alc268_ignore);
13000 	if (err < 0)
13001 		return err;
13002 	if (!spec->autocfg.line_outs) {
13003 		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13004 			spec->multiout.max_channels = 2;
13005 			spec->no_analog = 1;
13006 			goto dig_only;
13007 		}
13008 		return 0; /* can't find valid BIOS pin config */
13009 	}
13010 	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13011 	if (err < 0)
13012 		return err;
13013 	err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13014 	if (err < 0)
13015 		return err;
13016 
13017 	spec->multiout.max_channels = 2;
13018 
13019  dig_only:
13020 	/* digital only support output */
13021 	if (spec->autocfg.dig_outs) {
13022 		spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
13023 		spec->dig_out_type = spec->autocfg.dig_out_type[0];
13024 	}
13025 	if (spec->kctls.list)
13026 		add_mixer(spec, spec->kctls.list);
13027 
13028 	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13029 		add_mixer(spec, alc268_beep_mixer);
13030 
13031 	add_verb(spec, alc268_volume_init_verbs);
13032 	spec->num_mux_defs = 2;
13033 	spec->input_mux = &spec->private_imux[0];
13034 
13035 	err = alc_auto_add_mic_boost(codec);
13036 	if (err < 0)
13037 		return err;
13038 
13039 	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13040 
13041 	return 1;
13042 }
13043 
13044 #define alc268_auto_init_analog_input	alc882_auto_init_analog_input
13045 
13046 /* init callback for auto-configuration model -- overriding the default init */
13047 static void alc268_auto_init(struct hda_codec *codec)
13048 {
13049 	struct alc_spec *spec = codec->spec;
13050 	alc268_auto_init_multi_out(codec);
13051 	alc268_auto_init_hp_out(codec);
13052 	alc268_auto_init_mono_speaker_out(codec);
13053 	alc268_auto_init_analog_input(codec);
13054 	if (spec->unsol_event)
13055 		alc_inithook(codec);
13056 }
13057 
13058 /*
13059  * configuration and preset
13060  */
13061 static const char *alc268_models[ALC268_MODEL_LAST] = {
13062 	[ALC267_QUANTA_IL1]	= "quanta-il1",
13063 	[ALC268_3ST]		= "3stack",
13064 	[ALC268_TOSHIBA]	= "toshiba",
13065 	[ALC268_ACER]		= "acer",
13066 	[ALC268_ACER_DMIC]	= "acer-dmic",
13067 	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
13068 	[ALC268_DELL]		= "dell",
13069 	[ALC268_ZEPTO]		= "zepto",
13070 #ifdef CONFIG_SND_DEBUG
13071 	[ALC268_TEST]		= "test",
13072 #endif
13073 	[ALC268_AUTO]		= "auto",
13074 };
13075 
13076 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13077 	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13078 	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13079 	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13080 	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13081 	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13082 	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13083 						ALC268_ACER_ASPIRE_ONE),
13084 	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13085 	SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13086 			"Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13087 	/* almost compatible with toshiba but with optional digital outs;
13088 	 * auto-probing seems working fine
13089 	 */
13090 	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13091 			   ALC268_AUTO),
13092 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13093 	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13094 	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13095 	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13096 	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13097 	SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
13098 	{}
13099 };
13100 
13101 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13102 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13103 	SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13104 	SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13105 	SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13106 			   ALC268_TOSHIBA),
13107 	{}
13108 };
13109 
13110 static struct alc_config_preset alc268_presets[] = {
13111 	[ALC267_QUANTA_IL1] = {
13112 		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13113 			    alc268_capture_nosrc_mixer },
13114 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13115 				alc267_quanta_il1_verbs },
13116 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13117 		.dac_nids = alc268_dac_nids,
13118 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13119 		.adc_nids = alc268_adc_nids_alt,
13120 		.hp_nid = 0x03,
13121 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13122 		.channel_mode = alc268_modes,
13123 		.unsol_event = alc_sku_unsol_event,
13124 		.setup = alc267_quanta_il1_setup,
13125 		.init_hook = alc_inithook,
13126 	},
13127 	[ALC268_3ST] = {
13128 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13129 			    alc268_beep_mixer },
13130 		.init_verbs = { alc268_base_init_verbs },
13131 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13132 		.dac_nids = alc268_dac_nids,
13133                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13134                 .adc_nids = alc268_adc_nids_alt,
13135 		.capsrc_nids = alc268_capsrc_nids,
13136 		.hp_nid = 0x03,
13137 		.dig_out_nid = ALC268_DIGOUT_NID,
13138 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13139 		.channel_mode = alc268_modes,
13140 		.input_mux = &alc268_capture_source,
13141 	},
13142 	[ALC268_TOSHIBA] = {
13143 		.mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13144 			    alc268_beep_mixer },
13145 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13146 				alc268_toshiba_verbs },
13147 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13148 		.dac_nids = alc268_dac_nids,
13149 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13150 		.adc_nids = alc268_adc_nids_alt,
13151 		.capsrc_nids = alc268_capsrc_nids,
13152 		.hp_nid = 0x03,
13153 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13154 		.channel_mode = alc268_modes,
13155 		.input_mux = &alc268_capture_source,
13156 		.unsol_event = alc268_toshiba_unsol_event,
13157 		.setup = alc268_toshiba_setup,
13158 		.init_hook = alc268_toshiba_automute,
13159 	},
13160 	[ALC268_ACER] = {
13161 		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13162 			    alc268_beep_mixer },
13163 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13164 				alc268_acer_verbs },
13165 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13166 		.dac_nids = alc268_dac_nids,
13167 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13168 		.adc_nids = alc268_adc_nids_alt,
13169 		.capsrc_nids = alc268_capsrc_nids,
13170 		.hp_nid = 0x02,
13171 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13172 		.channel_mode = alc268_modes,
13173 		.input_mux = &alc268_acer_capture_source,
13174 		.unsol_event = alc268_acer_unsol_event,
13175 		.init_hook = alc268_acer_init_hook,
13176 	},
13177 	[ALC268_ACER_DMIC] = {
13178 		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13179 			    alc268_beep_mixer },
13180 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13181 				alc268_acer_verbs },
13182 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13183 		.dac_nids = alc268_dac_nids,
13184 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13185 		.adc_nids = alc268_adc_nids_alt,
13186 		.capsrc_nids = alc268_capsrc_nids,
13187 		.hp_nid = 0x02,
13188 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13189 		.channel_mode = alc268_modes,
13190 		.input_mux = &alc268_acer_dmic_capture_source,
13191 		.unsol_event = alc268_acer_unsol_event,
13192 		.init_hook = alc268_acer_init_hook,
13193 	},
13194 	[ALC268_ACER_ASPIRE_ONE] = {
13195 		.mixers = { alc268_acer_aspire_one_mixer,
13196 			    alc268_beep_mixer,
13197 			    alc268_capture_nosrc_mixer },
13198 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13199 				alc268_acer_aspire_one_verbs },
13200 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13201 		.dac_nids = alc268_dac_nids,
13202 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13203 		.adc_nids = alc268_adc_nids_alt,
13204 		.capsrc_nids = alc268_capsrc_nids,
13205 		.hp_nid = 0x03,
13206 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13207 		.channel_mode = alc268_modes,
13208 		.unsol_event = alc268_acer_lc_unsol_event,
13209 		.setup = alc268_acer_lc_setup,
13210 		.init_hook = alc268_acer_lc_init_hook,
13211 	},
13212 	[ALC268_DELL] = {
13213 		.mixers = { alc268_dell_mixer, alc268_beep_mixer,
13214 			    alc268_capture_nosrc_mixer },
13215 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13216 				alc268_dell_verbs },
13217 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13218 		.dac_nids = alc268_dac_nids,
13219 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13220 		.adc_nids = alc268_adc_nids_alt,
13221 		.capsrc_nids = alc268_capsrc_nids,
13222 		.hp_nid = 0x02,
13223 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13224 		.channel_mode = alc268_modes,
13225 		.unsol_event = alc_sku_unsol_event,
13226 		.setup = alc268_dell_setup,
13227 		.init_hook = alc_inithook,
13228 	},
13229 	[ALC268_ZEPTO] = {
13230 		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13231 			    alc268_beep_mixer },
13232 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13233 				alc268_toshiba_verbs },
13234 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13235 		.dac_nids = alc268_dac_nids,
13236 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13237 		.adc_nids = alc268_adc_nids_alt,
13238 		.capsrc_nids = alc268_capsrc_nids,
13239 		.hp_nid = 0x03,
13240 		.dig_out_nid = ALC268_DIGOUT_NID,
13241 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13242 		.channel_mode = alc268_modes,
13243 		.input_mux = &alc268_capture_source,
13244 		.setup = alc268_toshiba_setup,
13245 		.init_hook = alc268_toshiba_automute,
13246 	},
13247 #ifdef CONFIG_SND_DEBUG
13248 	[ALC268_TEST] = {
13249 		.mixers = { alc268_test_mixer, alc268_capture_mixer },
13250 		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13251 				alc268_volume_init_verbs },
13252 		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13253 		.dac_nids = alc268_dac_nids,
13254 		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13255 		.adc_nids = alc268_adc_nids_alt,
13256 		.capsrc_nids = alc268_capsrc_nids,
13257 		.hp_nid = 0x03,
13258 		.dig_out_nid = ALC268_DIGOUT_NID,
13259 		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13260 		.channel_mode = alc268_modes,
13261 		.input_mux = &alc268_capture_source,
13262 	},
13263 #endif
13264 };
13265 
13266 static int patch_alc268(struct hda_codec *codec)
13267 {
13268 	struct alc_spec *spec;
13269 	int board_config;
13270 	int i, has_beep, err;
13271 
13272 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13273 	if (spec == NULL)
13274 		return -ENOMEM;
13275 
13276 	codec->spec = spec;
13277 
13278 	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13279 						  alc268_models,
13280 						  alc268_cfg_tbl);
13281 
13282 	if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13283 		board_config = snd_hda_check_board_codec_sid_config(codec,
13284 			ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13285 
13286 	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13287 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13288 		       codec->chip_name);
13289 		board_config = ALC268_AUTO;
13290 	}
13291 
13292 	if (board_config == ALC268_AUTO) {
13293 		/* automatic parse from the BIOS config */
13294 		err = alc268_parse_auto_config(codec);
13295 		if (err < 0) {
13296 			alc_free(codec);
13297 			return err;
13298 		} else if (!err) {
13299 			printk(KERN_INFO
13300 			       "hda_codec: Cannot set up configuration "
13301 			       "from BIOS.  Using base mode...\n");
13302 			board_config = ALC268_3ST;
13303 		}
13304 	}
13305 
13306 	if (board_config != ALC268_AUTO)
13307 		setup_preset(codec, &alc268_presets[board_config]);
13308 
13309 	spec->stream_analog_playback = &alc268_pcm_analog_playback;
13310 	spec->stream_analog_capture = &alc268_pcm_analog_capture;
13311 	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13312 
13313 	spec->stream_digital_playback = &alc268_pcm_digital_playback;
13314 
13315 	has_beep = 0;
13316 	for (i = 0; i < spec->num_mixers; i++) {
13317 		if (spec->mixers[i] == alc268_beep_mixer) {
13318 			has_beep = 1;
13319 			break;
13320 		}
13321 	}
13322 
13323 	if (has_beep) {
13324 		err = snd_hda_attach_beep_device(codec, 0x1);
13325 		if (err < 0) {
13326 			alc_free(codec);
13327 			return err;
13328 		}
13329 		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13330 			/* override the amp caps for beep generator */
13331 			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13332 					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13333 					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13334 					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13335 					  (0 << AC_AMPCAP_MUTE_SHIFT));
13336 	}
13337 
13338 	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13339 		/* check whether NID 0x07 is valid */
13340 		unsigned int wcap = get_wcaps(codec, 0x07);
13341 		int i;
13342 
13343 		spec->capsrc_nids = alc268_capsrc_nids;
13344 		/* get type */
13345 		wcap = get_wcaps_type(wcap);
13346 		if (spec->auto_mic ||
13347 		    wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13348 			spec->adc_nids = alc268_adc_nids_alt;
13349 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13350 			if (spec->auto_mic)
13351 				fixup_automic_adc(codec);
13352 			if (spec->auto_mic || spec->input_mux->num_items == 1)
13353 				add_mixer(spec, alc268_capture_nosrc_mixer);
13354 			else
13355 				add_mixer(spec, alc268_capture_alt_mixer);
13356 		} else {
13357 			spec->adc_nids = alc268_adc_nids;
13358 			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13359 			add_mixer(spec, alc268_capture_mixer);
13360 		}
13361 		/* set default input source */
13362 		for (i = 0; i < spec->num_adc_nids; i++)
13363 			snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13364 				0, AC_VERB_SET_CONNECT_SEL,
13365 				i < spec->num_mux_defs ?
13366 				spec->input_mux[i].items[0].index :
13367 				spec->input_mux->items[0].index);
13368 	}
13369 
13370 	spec->vmaster_nid = 0x02;
13371 
13372 	codec->patch_ops = alc_patch_ops;
13373 	if (board_config == ALC268_AUTO)
13374 		spec->init_hook = alc268_auto_init;
13375 
13376 	return 0;
13377 }
13378 
13379 /*
13380  *  ALC269 channel source setting (2 channel)
13381  */
13382 #define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
13383 
13384 #define alc269_dac_nids		alc260_dac_nids
13385 
13386 static hda_nid_t alc269_adc_nids[1] = {
13387 	/* ADC1 */
13388 	0x08,
13389 };
13390 
13391 static hda_nid_t alc269_capsrc_nids[1] = {
13392 	0x23,
13393 };
13394 
13395 static hda_nid_t alc269vb_adc_nids[1] = {
13396 	/* ADC1 */
13397 	0x09,
13398 };
13399 
13400 static hda_nid_t alc269vb_capsrc_nids[1] = {
13401 	0x22,
13402 };
13403 
13404 static hda_nid_t alc269_adc_candidates[] = {
13405 	0x08, 0x09, 0x07,
13406 };
13407 
13408 #define alc269_modes		alc260_modes
13409 #define alc269_capture_source	alc880_lg_lw_capture_source
13410 
13411 static struct snd_kcontrol_new alc269_base_mixer[] = {
13412 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13413 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13414 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13415 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13416 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13417 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13418 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13419 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13420 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13421 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13422 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13423 	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13424 	{ } /* end */
13425 };
13426 
13427 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13428 	/* output mixer control */
13429 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13430 	{
13431 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13432 		.name = "Master Playback Switch",
13433 		.subdevice = HDA_SUBDEV_AMP_FLAG,
13434 		.info = snd_hda_mixer_amp_switch_info,
13435 		.get = snd_hda_mixer_amp_switch_get,
13436 		.put = alc268_acer_master_sw_put,
13437 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13438 	},
13439 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13440 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13441 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13442 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13443 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13444 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13445 	{ }
13446 };
13447 
13448 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13449 	/* output mixer control */
13450 	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13451 	{
13452 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13453 		.name = "Master Playback Switch",
13454 		.subdevice = HDA_SUBDEV_AMP_FLAG,
13455 		.info = snd_hda_mixer_amp_switch_info,
13456 		.get = snd_hda_mixer_amp_switch_get,
13457 		.put = alc268_acer_master_sw_put,
13458 		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13459 	},
13460 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13461 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13462 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13463 	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13464 	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13465 	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13466 	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13467 	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13468 	HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13469 	{ }
13470 };
13471 
13472 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
13473 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13474 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13475 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13476 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13477 	{ } /* end */
13478 };
13479 
13480 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
13481 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13482 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13483 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13484 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13485 	{ } /* end */
13486 };
13487 
13488 /* capture mixer elements */
13489 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
13490 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13491 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13492 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13493 	HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13494 	{ } /* end */
13495 };
13496 
13497 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
13498 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13499 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13500 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13501 	{ } /* end */
13502 };
13503 
13504 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
13505 	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13506 	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13507 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13508 	HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13509 	{ } /* end */
13510 };
13511 
13512 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
13513 	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13514 	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13515 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13516 	{ } /* end */
13517 };
13518 
13519 /* FSC amilo */
13520 #define alc269_fujitsu_mixer	alc269_laptop_mixer
13521 
13522 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13523 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13524 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13525 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13526 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13527 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13528 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13529 	{ }
13530 };
13531 
13532 static struct hda_verb alc269_lifebook_verbs[] = {
13533 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13534 	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13535 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13536 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13537 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13538 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13539 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13540 	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13541 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13542 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13543 	{ }
13544 };
13545 
13546 /* toggle speaker-output according to the hp-jack state */
13547 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13548 {
13549 	unsigned int present;
13550 	unsigned char bits;
13551 
13552 	present = snd_hda_jack_detect(codec, 0x15);
13553 	bits = present ? HDA_AMP_MUTE : 0;
13554 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13555 				 HDA_AMP_MUTE, bits);
13556 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13557 				 HDA_AMP_MUTE, bits);
13558 
13559 	snd_hda_codec_write(codec, 0x20, 0,
13560 			AC_VERB_SET_COEF_INDEX, 0x0c);
13561 	snd_hda_codec_write(codec, 0x20, 0,
13562 			AC_VERB_SET_PROC_COEF, 0x680);
13563 
13564 	snd_hda_codec_write(codec, 0x20, 0,
13565 			AC_VERB_SET_COEF_INDEX, 0x0c);
13566 	snd_hda_codec_write(codec, 0x20, 0,
13567 			AC_VERB_SET_PROC_COEF, 0x480);
13568 }
13569 
13570 /* toggle speaker-output according to the hp-jacks state */
13571 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13572 {
13573 	unsigned int present;
13574 	unsigned char bits;
13575 
13576 	/* Check laptop headphone socket */
13577 	present = snd_hda_jack_detect(codec, 0x15);
13578 
13579 	/* Check port replicator headphone socket */
13580 	present |= snd_hda_jack_detect(codec, 0x1a);
13581 
13582 	bits = present ? HDA_AMP_MUTE : 0;
13583 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13584 				 HDA_AMP_MUTE, bits);
13585 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13586 				 HDA_AMP_MUTE, bits);
13587 
13588 	snd_hda_codec_write(codec, 0x20, 0,
13589 			AC_VERB_SET_COEF_INDEX, 0x0c);
13590 	snd_hda_codec_write(codec, 0x20, 0,
13591 			AC_VERB_SET_PROC_COEF, 0x680);
13592 
13593 	snd_hda_codec_write(codec, 0x20, 0,
13594 			AC_VERB_SET_COEF_INDEX, 0x0c);
13595 	snd_hda_codec_write(codec, 0x20, 0,
13596 			AC_VERB_SET_PROC_COEF, 0x480);
13597 }
13598 
13599 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13600 {
13601 	unsigned int present_laptop;
13602 	unsigned int present_dock;
13603 
13604 	present_laptop	= snd_hda_jack_detect(codec, 0x18);
13605 	present_dock	= snd_hda_jack_detect(codec, 0x1b);
13606 
13607 	/* Laptop mic port overrides dock mic port, design decision */
13608 	if (present_dock)
13609 		snd_hda_codec_write(codec, 0x23, 0,
13610 				AC_VERB_SET_CONNECT_SEL, 0x3);
13611 	if (present_laptop)
13612 		snd_hda_codec_write(codec, 0x23, 0,
13613 				AC_VERB_SET_CONNECT_SEL, 0x0);
13614 	if (!present_dock && !present_laptop)
13615 		snd_hda_codec_write(codec, 0x23, 0,
13616 				AC_VERB_SET_CONNECT_SEL, 0x1);
13617 }
13618 
13619 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13620 				    unsigned int res)
13621 {
13622 	switch (res >> 26) {
13623 	case ALC880_HP_EVENT:
13624 		alc269_quanta_fl1_speaker_automute(codec);
13625 		break;
13626 	case ALC880_MIC_EVENT:
13627 		alc_mic_automute(codec);
13628 		break;
13629 	}
13630 }
13631 
13632 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13633 					unsigned int res)
13634 {
13635 	if ((res >> 26) == ALC880_HP_EVENT)
13636 		alc269_lifebook_speaker_automute(codec);
13637 	if ((res >> 26) == ALC880_MIC_EVENT)
13638 		alc269_lifebook_mic_autoswitch(codec);
13639 }
13640 
13641 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13642 {
13643 	struct alc_spec *spec = codec->spec;
13644 	spec->autocfg.hp_pins[0] = 0x15;
13645 	spec->autocfg.speaker_pins[0] = 0x14;
13646 	spec->ext_mic.pin = 0x18;
13647 	spec->ext_mic.mux_idx = 0;
13648 	spec->int_mic.pin = 0x19;
13649 	spec->int_mic.mux_idx = 1;
13650 	spec->auto_mic = 1;
13651 }
13652 
13653 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13654 {
13655 	alc269_quanta_fl1_speaker_automute(codec);
13656 	alc_mic_automute(codec);
13657 }
13658 
13659 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13660 {
13661 	alc269_lifebook_speaker_automute(codec);
13662 	alc269_lifebook_mic_autoswitch(codec);
13663 }
13664 
13665 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
13666 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13667 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13668 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13669 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13670 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13671 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13672 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13673 	{}
13674 };
13675 
13676 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
13677 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13678 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13679 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13680 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13681 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13682 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13683 	{}
13684 };
13685 
13686 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
13687 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13688 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
13689 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13690 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13691 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13692 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13693 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13694 	{}
13695 };
13696 
13697 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
13698 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13699 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
13700 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13701 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13702 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13703 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13704 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13705 	{}
13706 };
13707 
13708 /* toggle speaker-output according to the hp-jack state */
13709 static void alc269_speaker_automute(struct hda_codec *codec)
13710 {
13711 	struct alc_spec *spec = codec->spec;
13712 	unsigned int nid = spec->autocfg.hp_pins[0];
13713 	unsigned int present;
13714 	unsigned char bits;
13715 
13716 	present = snd_hda_jack_detect(codec, nid);
13717 	bits = present ? HDA_AMP_MUTE : 0;
13718 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13719 				 HDA_AMP_MUTE, bits);
13720 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13721 				 HDA_AMP_MUTE, bits);
13722 }
13723 
13724 /* unsolicited event for HP jack sensing */
13725 static void alc269_laptop_unsol_event(struct hda_codec *codec,
13726 				     unsigned int res)
13727 {
13728 	switch (res >> 26) {
13729 	case ALC880_HP_EVENT:
13730 		alc269_speaker_automute(codec);
13731 		break;
13732 	case ALC880_MIC_EVENT:
13733 		alc_mic_automute(codec);
13734 		break;
13735 	}
13736 }
13737 
13738 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
13739 {
13740 	struct alc_spec *spec = codec->spec;
13741 	spec->autocfg.hp_pins[0] = 0x15;
13742 	spec->autocfg.speaker_pins[0] = 0x14;
13743 	spec->ext_mic.pin = 0x18;
13744 	spec->ext_mic.mux_idx = 0;
13745 	spec->int_mic.pin = 0x12;
13746 	spec->int_mic.mux_idx = 5;
13747 	spec->auto_mic = 1;
13748 }
13749 
13750 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
13751 {
13752 	struct alc_spec *spec = codec->spec;
13753 	spec->autocfg.hp_pins[0] = 0x15;
13754 	spec->autocfg.speaker_pins[0] = 0x14;
13755 	spec->ext_mic.pin = 0x18;
13756 	spec->ext_mic.mux_idx = 0;
13757 	spec->int_mic.pin = 0x12;
13758 	spec->int_mic.mux_idx = 6;
13759 	spec->auto_mic = 1;
13760 }
13761 
13762 static void alc269_laptop_amic_setup(struct hda_codec *codec)
13763 {
13764 	struct alc_spec *spec = codec->spec;
13765 	spec->autocfg.hp_pins[0] = 0x15;
13766 	spec->autocfg.speaker_pins[0] = 0x14;
13767 	spec->ext_mic.pin = 0x18;
13768 	spec->ext_mic.mux_idx = 0;
13769 	spec->int_mic.pin = 0x19;
13770 	spec->int_mic.mux_idx = 1;
13771 	spec->auto_mic = 1;
13772 }
13773 
13774 static void alc269_laptop_inithook(struct hda_codec *codec)
13775 {
13776 	alc269_speaker_automute(codec);
13777 	alc_mic_automute(codec);
13778 }
13779 
13780 /*
13781  * generic initialization of ADC, input mixers and output mixers
13782  */
13783 static struct hda_verb alc269_init_verbs[] = {
13784 	/*
13785 	 * Unmute ADC0 and set the default input to mic-in
13786 	 */
13787 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13788 
13789 	/*
13790 	 * Set up output mixers (0x02 - 0x03)
13791 	 */
13792 	/* set vol=0 to output mixers */
13793 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13794 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13795 
13796 	/* set up input amps for analog loopback */
13797 	/* Amp Indices: DAC = 0, mixer = 1 */
13798 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13799 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13800 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13801 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13802 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13803 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13804 
13805 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13806 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13807 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13808 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13809 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13810 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13811 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13812 
13813 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13814 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13815 
13816 	/* FIXME: use Mux-type input source selection */
13817 	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13818 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13819 	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13820 
13821 	/* set EAPD */
13822 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13823 	{ }
13824 };
13825 
13826 static struct hda_verb alc269vb_init_verbs[] = {
13827 	/*
13828 	 * Unmute ADC0 and set the default input to mic-in
13829 	 */
13830 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13831 
13832 	/*
13833 	 * Set up output mixers (0x02 - 0x03)
13834 	 */
13835 	/* set vol=0 to output mixers */
13836 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13837 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13838 
13839 	/* set up input amps for analog loopback */
13840 	/* Amp Indices: DAC = 0, mixer = 1 */
13841 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13842 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13843 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13844 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13845 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13846 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13847 
13848 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13849 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13850 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13851 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13852 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13853 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13854 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13855 
13856 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13857 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13858 
13859 	/* FIXME: use Mux-type input source selection */
13860 	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13861 	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13862 	{0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
13863 
13864 	/* set EAPD */
13865 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13866 	{ }
13867 };
13868 
13869 #define alc269_auto_create_multi_out_ctls \
13870 	alc268_auto_create_multi_out_ctls
13871 #define alc269_auto_create_input_ctls \
13872 	alc268_auto_create_input_ctls
13873 
13874 #ifdef CONFIG_SND_HDA_POWER_SAVE
13875 #define alc269_loopbacks	alc880_loopbacks
13876 #endif
13877 
13878 /* pcm configuration: identical with ALC880 */
13879 #define alc269_pcm_analog_playback	alc880_pcm_analog_playback
13880 #define alc269_pcm_analog_capture	alc880_pcm_analog_capture
13881 #define alc269_pcm_digital_playback	alc880_pcm_digital_playback
13882 #define alc269_pcm_digital_capture	alc880_pcm_digital_capture
13883 
13884 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13885 	.substreams = 1,
13886 	.channels_min = 2,
13887 	.channels_max = 8,
13888 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13889 	/* NID is set in alc_build_pcms */
13890 	.ops = {
13891 		.open = alc880_playback_pcm_open,
13892 		.prepare = alc880_playback_pcm_prepare,
13893 		.cleanup = alc880_playback_pcm_cleanup
13894 	},
13895 };
13896 
13897 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13898 	.substreams = 1,
13899 	.channels_min = 2,
13900 	.channels_max = 2,
13901 	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13902 	/* NID is set in alc_build_pcms */
13903 };
13904 
13905 /*
13906  * BIOS auto configuration
13907  */
13908 static int alc269_parse_auto_config(struct hda_codec *codec)
13909 {
13910 	struct alc_spec *spec = codec->spec;
13911 	int err;
13912 	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13913 
13914 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13915 					   alc269_ignore);
13916 	if (err < 0)
13917 		return err;
13918 
13919 	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13920 	if (err < 0)
13921 		return err;
13922 	err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13923 	if (err < 0)
13924 		return err;
13925 
13926 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13927 
13928 	if (spec->autocfg.dig_outs)
13929 		spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13930 
13931 	if (spec->kctls.list)
13932 		add_mixer(spec, spec->kctls.list);
13933 
13934 	if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) {
13935 		add_verb(spec, alc269vb_init_verbs);
13936 		alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
13937 	} else {
13938 		add_verb(spec, alc269_init_verbs);
13939 		alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13940 	}
13941 
13942 	spec->num_mux_defs = 1;
13943 	spec->input_mux = &spec->private_imux[0];
13944 	fillup_priv_adc_nids(codec, alc269_adc_candidates,
13945 			     sizeof(alc269_adc_candidates));
13946 
13947 	/* set default input source */
13948 	snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
13949 				  0, AC_VERB_SET_CONNECT_SEL,
13950 				  spec->input_mux->items[0].index);
13951 
13952 	err = alc_auto_add_mic_boost(codec);
13953 	if (err < 0)
13954 		return err;
13955 
13956 	if (!spec->cap_mixer && !spec->no_analog)
13957 		set_capture_mixer(codec);
13958 
13959 	return 1;
13960 }
13961 
13962 #define alc269_auto_init_multi_out	alc268_auto_init_multi_out
13963 #define alc269_auto_init_hp_out		alc268_auto_init_hp_out
13964 #define alc269_auto_init_analog_input	alc882_auto_init_analog_input
13965 
13966 
13967 /* init callback for auto-configuration model -- overriding the default init */
13968 static void alc269_auto_init(struct hda_codec *codec)
13969 {
13970 	struct alc_spec *spec = codec->spec;
13971 	alc269_auto_init_multi_out(codec);
13972 	alc269_auto_init_hp_out(codec);
13973 	alc269_auto_init_analog_input(codec);
13974 	if (spec->unsol_event)
13975 		alc_inithook(codec);
13976 }
13977 
13978 /*
13979  * configuration and preset
13980  */
13981 static const char *alc269_models[ALC269_MODEL_LAST] = {
13982 	[ALC269_BASIC]			= "basic",
13983 	[ALC269_QUANTA_FL1]		= "quanta",
13984 	[ALC269_AMIC]			= "laptop-amic",
13985 	[ALC269_DMIC]			= "laptop-dmic",
13986 	[ALC269_FUJITSU]		= "fujitsu",
13987 	[ALC269_LIFEBOOK]		= "lifebook",
13988 	[ALC269_AUTO]			= "auto",
13989 };
13990 
13991 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13992 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13993 	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13994 		      ALC269_AMIC),
13995 	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
13996 	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
13997 	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
13998 	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
13999 	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14000 	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14001 	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14002 	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14003 	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14004 	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14005 	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14006 	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14007 	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14008 	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14009 	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14010 	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14011 	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14012 	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14013 	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14014 	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14015 	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14016 	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14017 	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14018 	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14019 	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14020 	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14021 	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14022 	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14023 	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14024 	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14025 	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14026 	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14027 	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14028 	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14029 	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14030 	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14031 	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14032 		      ALC269_DMIC),
14033 	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14034 		      ALC269_DMIC),
14035 	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14036 	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14037 	SND_PCI_QUIRK(0x104d, 0x9071, "SONY XTB", ALC269_DMIC),
14038 	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14039 	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14040 	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14041 	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14042 	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14043 	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14044 	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14045 	{}
14046 };
14047 
14048 static struct alc_config_preset alc269_presets[] = {
14049 	[ALC269_BASIC] = {
14050 		.mixers = { alc269_base_mixer },
14051 		.init_verbs = { alc269_init_verbs },
14052 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14053 		.dac_nids = alc269_dac_nids,
14054 		.hp_nid = 0x03,
14055 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14056 		.channel_mode = alc269_modes,
14057 		.input_mux = &alc269_capture_source,
14058 	},
14059 	[ALC269_QUANTA_FL1] = {
14060 		.mixers = { alc269_quanta_fl1_mixer },
14061 		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14062 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14063 		.dac_nids = alc269_dac_nids,
14064 		.hp_nid = 0x03,
14065 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14066 		.channel_mode = alc269_modes,
14067 		.input_mux = &alc269_capture_source,
14068 		.unsol_event = alc269_quanta_fl1_unsol_event,
14069 		.setup = alc269_quanta_fl1_setup,
14070 		.init_hook = alc269_quanta_fl1_init_hook,
14071 	},
14072 	[ALC269_AMIC] = {
14073 		.mixers = { alc269_laptop_mixer },
14074 		.cap_mixer = alc269_laptop_analog_capture_mixer,
14075 		.init_verbs = { alc269_init_verbs,
14076 				alc269_laptop_amic_init_verbs },
14077 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14078 		.dac_nids = alc269_dac_nids,
14079 		.hp_nid = 0x03,
14080 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14081 		.channel_mode = alc269_modes,
14082 		.unsol_event = alc269_laptop_unsol_event,
14083 		.setup = alc269_laptop_amic_setup,
14084 		.init_hook = alc269_laptop_inithook,
14085 	},
14086 	[ALC269_DMIC] = {
14087 		.mixers = { alc269_laptop_mixer },
14088 		.cap_mixer = alc269_laptop_digital_capture_mixer,
14089 		.init_verbs = { alc269_init_verbs,
14090 				alc269_laptop_dmic_init_verbs },
14091 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14092 		.dac_nids = alc269_dac_nids,
14093 		.hp_nid = 0x03,
14094 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14095 		.channel_mode = alc269_modes,
14096 		.unsol_event = alc269_laptop_unsol_event,
14097 		.setup = alc269_laptop_dmic_setup,
14098 		.init_hook = alc269_laptop_inithook,
14099 	},
14100 	[ALC269VB_AMIC] = {
14101 		.mixers = { alc269vb_laptop_mixer },
14102 		.cap_mixer = alc269vb_laptop_analog_capture_mixer,
14103 		.init_verbs = { alc269vb_init_verbs,
14104 				alc269vb_laptop_amic_init_verbs },
14105 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14106 		.dac_nids = alc269_dac_nids,
14107 		.hp_nid = 0x03,
14108 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14109 		.channel_mode = alc269_modes,
14110 		.unsol_event = alc269_laptop_unsol_event,
14111 		.setup = alc269_laptop_amic_setup,
14112 		.init_hook = alc269_laptop_inithook,
14113 	},
14114 	[ALC269VB_DMIC] = {
14115 		.mixers = { alc269vb_laptop_mixer },
14116 		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
14117 		.init_verbs = { alc269vb_init_verbs,
14118 				alc269vb_laptop_dmic_init_verbs },
14119 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14120 		.dac_nids = alc269_dac_nids,
14121 		.hp_nid = 0x03,
14122 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14123 		.channel_mode = alc269_modes,
14124 		.unsol_event = alc269_laptop_unsol_event,
14125 		.setup = alc269vb_laptop_dmic_setup,
14126 		.init_hook = alc269_laptop_inithook,
14127 	},
14128 	[ALC269_FUJITSU] = {
14129 		.mixers = { alc269_fujitsu_mixer },
14130 		.cap_mixer = alc269_laptop_digital_capture_mixer,
14131 		.init_verbs = { alc269_init_verbs,
14132 				alc269_laptop_dmic_init_verbs },
14133 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14134 		.dac_nids = alc269_dac_nids,
14135 		.hp_nid = 0x03,
14136 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14137 		.channel_mode = alc269_modes,
14138 		.unsol_event = alc269_laptop_unsol_event,
14139 		.setup = alc269_laptop_dmic_setup,
14140 		.init_hook = alc269_laptop_inithook,
14141 	},
14142 	[ALC269_LIFEBOOK] = {
14143 		.mixers = { alc269_lifebook_mixer },
14144 		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14145 		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14146 		.dac_nids = alc269_dac_nids,
14147 		.hp_nid = 0x03,
14148 		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14149 		.channel_mode = alc269_modes,
14150 		.input_mux = &alc269_capture_source,
14151 		.unsol_event = alc269_lifebook_unsol_event,
14152 		.init_hook = alc269_lifebook_init_hook,
14153 	},
14154 };
14155 
14156 static int patch_alc269(struct hda_codec *codec)
14157 {
14158 	struct alc_spec *spec;
14159 	int board_config;
14160 	int err;
14161 	int is_alc269vb = 0;
14162 
14163 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14164 	if (spec == NULL)
14165 		return -ENOMEM;
14166 
14167 	codec->spec = spec;
14168 
14169 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
14170 
14171 	if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14172 		kfree(codec->chip_name);
14173 		codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
14174 		if (!codec->chip_name) {
14175 			alc_free(codec);
14176 			return -ENOMEM;
14177 		}
14178 		is_alc269vb = 1;
14179 	}
14180 
14181 	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14182 						  alc269_models,
14183 						  alc269_cfg_tbl);
14184 
14185 	if (board_config < 0) {
14186 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14187 		       codec->chip_name);
14188 		board_config = ALC269_AUTO;
14189 	}
14190 
14191 	if (board_config == ALC269_AUTO) {
14192 		/* automatic parse from the BIOS config */
14193 		err = alc269_parse_auto_config(codec);
14194 		if (err < 0) {
14195 			alc_free(codec);
14196 			return err;
14197 		} else if (!err) {
14198 			printk(KERN_INFO
14199 			       "hda_codec: Cannot set up configuration "
14200 			       "from BIOS.  Using base mode...\n");
14201 			board_config = ALC269_BASIC;
14202 		}
14203 	}
14204 
14205 	err = snd_hda_attach_beep_device(codec, 0x1);
14206 	if (err < 0) {
14207 		alc_free(codec);
14208 		return err;
14209 	}
14210 
14211 	if (board_config != ALC269_AUTO)
14212 		setup_preset(codec, &alc269_presets[board_config]);
14213 
14214 	if (board_config == ALC269_QUANTA_FL1) {
14215 		/* Due to a hardware problem on Lenovo Ideadpad, we need to
14216 		 * fix the sample rate of analog I/O to 44.1kHz
14217 		 */
14218 		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
14219 		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
14220 	} else {
14221 		spec->stream_analog_playback = &alc269_pcm_analog_playback;
14222 		spec->stream_analog_capture = &alc269_pcm_analog_capture;
14223 	}
14224 	spec->stream_digital_playback = &alc269_pcm_digital_playback;
14225 	spec->stream_digital_capture = &alc269_pcm_digital_capture;
14226 
14227 	if (!spec->adc_nids) { /* wasn't filled automatically? use default */
14228 		if (!is_alc269vb) {
14229 			spec->adc_nids = alc269_adc_nids;
14230 			spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
14231 			spec->capsrc_nids = alc269_capsrc_nids;
14232 		} else {
14233 			spec->adc_nids = alc269vb_adc_nids;
14234 			spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
14235 			spec->capsrc_nids = alc269vb_capsrc_nids;
14236 		}
14237 	}
14238 
14239 	if (!spec->cap_mixer)
14240 		set_capture_mixer(codec);
14241 	set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
14242 
14243 	spec->vmaster_nid = 0x02;
14244 
14245 	codec->patch_ops = alc_patch_ops;
14246 	if (board_config == ALC269_AUTO)
14247 		spec->init_hook = alc269_auto_init;
14248 #ifdef CONFIG_SND_HDA_POWER_SAVE
14249 	if (!spec->loopback.amplist)
14250 		spec->loopback.amplist = alc269_loopbacks;
14251 #endif
14252 
14253 	return 0;
14254 }
14255 
14256 /*
14257  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
14258  */
14259 
14260 /*
14261  * set the path ways for 2 channel output
14262  * need to set the codec line out and mic 1 pin widgets to inputs
14263  */
14264 static struct hda_verb alc861_threestack_ch2_init[] = {
14265 	/* set pin widget 1Ah (line in) for input */
14266 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14267 	/* set pin widget 18h (mic1/2) for input, for mic also enable
14268 	 * the vref
14269 	 */
14270 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14271 
14272 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14273 #if 0
14274 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14275 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14276 #endif
14277 	{ } /* end */
14278 };
14279 /*
14280  * 6ch mode
14281  * need to set the codec line out and mic 1 pin widgets to outputs
14282  */
14283 static struct hda_verb alc861_threestack_ch6_init[] = {
14284 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
14285 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14286 	/* set pin widget 18h (mic1) for output (CLFE)*/
14287 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14288 
14289 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14290 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14291 
14292 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14293 #if 0
14294 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14295 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14296 #endif
14297 	{ } /* end */
14298 };
14299 
14300 static struct hda_channel_mode alc861_threestack_modes[2] = {
14301 	{ 2, alc861_threestack_ch2_init },
14302 	{ 6, alc861_threestack_ch6_init },
14303 };
14304 /* Set mic1 as input and unmute the mixer */
14305 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
14306 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14307 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14308 	{ } /* end */
14309 };
14310 /* Set mic1 as output and mute mixer */
14311 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
14312 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14313 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14314 	{ } /* end */
14315 };
14316 
14317 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
14318 	{ 2, alc861_uniwill_m31_ch2_init },
14319 	{ 4, alc861_uniwill_m31_ch4_init },
14320 };
14321 
14322 /* Set mic1 and line-in as input and unmute the mixer */
14323 static struct hda_verb alc861_asus_ch2_init[] = {
14324 	/* set pin widget 1Ah (line in) for input */
14325 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14326 	/* set pin widget 18h (mic1/2) for input, for mic also enable
14327 	 * the vref
14328 	 */
14329 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14330 
14331 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14332 #if 0
14333 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14334 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14335 #endif
14336 	{ } /* end */
14337 };
14338 /* Set mic1 nad line-in as output and mute mixer */
14339 static struct hda_verb alc861_asus_ch6_init[] = {
14340 	/* set pin widget 1Ah (line in) for output (Back Surround)*/
14341 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14342 	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14343 	/* set pin widget 18h (mic1) for output (CLFE)*/
14344 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14345 	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14346 	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14347 	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14348 
14349 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14350 #if 0
14351 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14352 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14353 #endif
14354 	{ } /* end */
14355 };
14356 
14357 static struct hda_channel_mode alc861_asus_modes[2] = {
14358 	{ 2, alc861_asus_ch2_init },
14359 	{ 6, alc861_asus_ch6_init },
14360 };
14361 
14362 /* patch-ALC861 */
14363 
14364 static struct snd_kcontrol_new alc861_base_mixer[] = {
14365         /* output mixer control */
14366 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14367 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14368 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14369 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14370 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14371 
14372         /*Input mixer control */
14373 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14374 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14375 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14376 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14377 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14378 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14379 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14380 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14381 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14382 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14383 
14384 	{ } /* end */
14385 };
14386 
14387 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
14388         /* output mixer control */
14389 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14390 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14391 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14392 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14393 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14394 
14395 	/* Input mixer control */
14396 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14397 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14398 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14399 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14400 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14401 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14402 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14403 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14404 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14405 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14406 
14407 	{
14408 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14409 		.name = "Channel Mode",
14410 		.info = alc_ch_mode_info,
14411 		.get = alc_ch_mode_get,
14412 		.put = alc_ch_mode_put,
14413                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
14414 	},
14415 	{ } /* end */
14416 };
14417 
14418 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
14419         /* output mixer control */
14420 	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14421 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14422 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14423 
14424 	{ } /* end */
14425 };
14426 
14427 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
14428         /* output mixer control */
14429 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14430 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14431 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14432 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14433 	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14434 
14435 	/* Input mixer control */
14436 	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14437 	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14438 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14439 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14440 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14441 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14442 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14443 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14444 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14445 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14446 
14447 	{
14448 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14449 		.name = "Channel Mode",
14450 		.info = alc_ch_mode_info,
14451 		.get = alc_ch_mode_get,
14452 		.put = alc_ch_mode_put,
14453                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
14454 	},
14455 	{ } /* end */
14456 };
14457 
14458 static struct snd_kcontrol_new alc861_asus_mixer[] = {
14459         /* output mixer control */
14460 	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14461 	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14462 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14463 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14464 	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14465 
14466 	/* Input mixer control */
14467 	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14468 	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14469 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14470 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14471 	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14472 	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14473 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14474 	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14475 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14476 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
14477 
14478 	{
14479 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14480 		.name = "Channel Mode",
14481 		.info = alc_ch_mode_info,
14482 		.get = alc_ch_mode_get,
14483 		.put = alc_ch_mode_put,
14484                 .private_value = ARRAY_SIZE(alc861_asus_modes),
14485 	},
14486 	{ }
14487 };
14488 
14489 /* additional mixer */
14490 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
14491 	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14492 	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14493 	{ }
14494 };
14495 
14496 /*
14497  * generic initialization of ADC, input mixers and output mixers
14498  */
14499 static struct hda_verb alc861_base_init_verbs[] = {
14500 	/*
14501 	 * Unmute ADC0 and set the default input to mic-in
14502 	 */
14503 	/* port-A for surround (rear panel) */
14504 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14505 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14506 	/* port-B for mic-in (rear panel) with vref */
14507 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14508 	/* port-C for line-in (rear panel) */
14509 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14510 	/* port-D for Front */
14511 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14512 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14513 	/* port-E for HP out (front panel) */
14514 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14515 	/* route front PCM to HP */
14516 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14517 	/* port-F for mic-in (front panel) with vref */
14518 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14519 	/* port-G for CLFE (rear panel) */
14520 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14521 	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14522 	/* port-H for side (rear panel) */
14523 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14524 	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14525 	/* CD-in */
14526 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14527 	/* route front mic to ADC1*/
14528 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14529 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14530 
14531 	/* Unmute DAC0~3 & spdif out*/
14532 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14533 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14534 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14535 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14536 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14537 
14538 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14539 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14540         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14541 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14542         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14543 
14544 	/* Unmute Stereo Mixer 15 */
14545 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14546 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14547 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14548 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14549 
14550 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14551 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14552 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14553 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14554 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14555 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14556 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14557 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14558 	/* hp used DAC 3 (Front) */
14559 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14560         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14561 
14562 	{ }
14563 };
14564 
14565 static struct hda_verb alc861_threestack_init_verbs[] = {
14566 	/*
14567 	 * Unmute ADC0 and set the default input to mic-in
14568 	 */
14569 	/* port-A for surround (rear panel) */
14570 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14571 	/* port-B for mic-in (rear panel) with vref */
14572 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14573 	/* port-C for line-in (rear panel) */
14574 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14575 	/* port-D for Front */
14576 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14577 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14578 	/* port-E for HP out (front panel) */
14579 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14580 	/* route front PCM to HP */
14581 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14582 	/* port-F for mic-in (front panel) with vref */
14583 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14584 	/* port-G for CLFE (rear panel) */
14585 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14586 	/* port-H for side (rear panel) */
14587 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14588 	/* CD-in */
14589 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14590 	/* route front mic to ADC1*/
14591 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14592 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14593 	/* Unmute DAC0~3 & spdif out*/
14594 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14595 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14596 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14597 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14598 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14599 
14600 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14601 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14602         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14603 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14604         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14605 
14606 	/* Unmute Stereo Mixer 15 */
14607 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14608 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14609 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14610 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14611 
14612 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14613 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14614 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14615 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14616 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14617 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14618 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14619 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14620 	/* hp used DAC 3 (Front) */
14621 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14622         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14623 	{ }
14624 };
14625 
14626 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14627 	/*
14628 	 * Unmute ADC0 and set the default input to mic-in
14629 	 */
14630 	/* port-A for surround (rear panel) */
14631 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14632 	/* port-B for mic-in (rear panel) with vref */
14633 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14634 	/* port-C for line-in (rear panel) */
14635 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14636 	/* port-D for Front */
14637 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14638 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14639 	/* port-E for HP out (front panel) */
14640 	/* this has to be set to VREF80 */
14641 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14642 	/* route front PCM to HP */
14643 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14644 	/* port-F for mic-in (front panel) with vref */
14645 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14646 	/* port-G for CLFE (rear panel) */
14647 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14648 	/* port-H for side (rear panel) */
14649 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14650 	/* CD-in */
14651 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14652 	/* route front mic to ADC1*/
14653 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14654 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14655 	/* Unmute DAC0~3 & spdif out*/
14656 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14657 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14658 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14659 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14660 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14661 
14662 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14663 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14664         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14665 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14666         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14667 
14668 	/* Unmute Stereo Mixer 15 */
14669 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14670 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14671 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14672 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14673 
14674 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14675 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14676 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14677 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14678 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14679 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14680 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14681 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14682 	/* hp used DAC 3 (Front) */
14683 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14684         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14685 	{ }
14686 };
14687 
14688 static struct hda_verb alc861_asus_init_verbs[] = {
14689 	/*
14690 	 * Unmute ADC0 and set the default input to mic-in
14691 	 */
14692 	/* port-A for surround (rear panel)
14693 	 * according to codec#0 this is the HP jack
14694 	 */
14695 	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14696 	/* route front PCM to HP */
14697 	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14698 	/* port-B for mic-in (rear panel) with vref */
14699 	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14700 	/* port-C for line-in (rear panel) */
14701 	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14702 	/* port-D for Front */
14703 	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14704 	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14705 	/* port-E for HP out (front panel) */
14706 	/* this has to be set to VREF80 */
14707 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14708 	/* route front PCM to HP */
14709 	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14710 	/* port-F for mic-in (front panel) with vref */
14711 	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14712 	/* port-G for CLFE (rear panel) */
14713 	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14714 	/* port-H for side (rear panel) */
14715 	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14716 	/* CD-in */
14717 	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14718 	/* route front mic to ADC1*/
14719 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14720 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14721 	/* Unmute DAC0~3 & spdif out*/
14722 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14723 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14724 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14725 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14726 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14727 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14728 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14729         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14730 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14731         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14732 
14733 	/* Unmute Stereo Mixer 15 */
14734 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14735 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14736 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14737 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14738 
14739 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14740 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14741 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14742 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14743 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14744 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14745 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14746 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14747 	/* hp used DAC 3 (Front) */
14748 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14749 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14750 	{ }
14751 };
14752 
14753 /* additional init verbs for ASUS laptops */
14754 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14755 	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14756 	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14757 	{ }
14758 };
14759 
14760 /*
14761  * generic initialization of ADC, input mixers and output mixers
14762  */
14763 static struct hda_verb alc861_auto_init_verbs[] = {
14764 	/*
14765 	 * Unmute ADC0 and set the default input to mic-in
14766 	 */
14767 	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14768 	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14769 
14770 	/* Unmute DAC0~3 & spdif out*/
14771 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14772 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14773 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14774 	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14775 	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14776 
14777 	/* Unmute Mixer 14 (mic) 1c (Line in)*/
14778 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14779 	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14780 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14781 	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14782 
14783 	/* Unmute Stereo Mixer 15 */
14784 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14785 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14786 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14787 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14788 
14789 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14790 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14791 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14792 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14793 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14794 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14795 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14796 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14797 
14798 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14799 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14800 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14801 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14802 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14803 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14804 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14805 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14806 
14807 	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
14808 
14809 	{ }
14810 };
14811 
14812 static struct hda_verb alc861_toshiba_init_verbs[] = {
14813 	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14814 
14815 	{ }
14816 };
14817 
14818 /* toggle speaker-output according to the hp-jack state */
14819 static void alc861_toshiba_automute(struct hda_codec *codec)
14820 {
14821 	unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14822 
14823 	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14824 				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14825 	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14826 				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14827 }
14828 
14829 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14830 				       unsigned int res)
14831 {
14832 	if ((res >> 26) == ALC880_HP_EVENT)
14833 		alc861_toshiba_automute(codec);
14834 }
14835 
14836 /* pcm configuration: identical with ALC880 */
14837 #define alc861_pcm_analog_playback	alc880_pcm_analog_playback
14838 #define alc861_pcm_analog_capture	alc880_pcm_analog_capture
14839 #define alc861_pcm_digital_playback	alc880_pcm_digital_playback
14840 #define alc861_pcm_digital_capture	alc880_pcm_digital_capture
14841 
14842 
14843 #define ALC861_DIGOUT_NID	0x07
14844 
14845 static struct hda_channel_mode alc861_8ch_modes[1] = {
14846 	{ 8, NULL }
14847 };
14848 
14849 static hda_nid_t alc861_dac_nids[4] = {
14850 	/* front, surround, clfe, side */
14851 	0x03, 0x06, 0x05, 0x04
14852 };
14853 
14854 static hda_nid_t alc660_dac_nids[3] = {
14855 	/* front, clfe, surround */
14856 	0x03, 0x05, 0x06
14857 };
14858 
14859 static hda_nid_t alc861_adc_nids[1] = {
14860 	/* ADC0-2 */
14861 	0x08,
14862 };
14863 
14864 static struct hda_input_mux alc861_capture_source = {
14865 	.num_items = 5,
14866 	.items = {
14867 		{ "Mic", 0x0 },
14868 		{ "Front Mic", 0x3 },
14869 		{ "Line", 0x1 },
14870 		{ "CD", 0x4 },
14871 		{ "Mixer", 0x5 },
14872 	},
14873 };
14874 
14875 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14876 {
14877 	struct alc_spec *spec = codec->spec;
14878 	hda_nid_t mix, srcs[5];
14879 	int i, j, num;
14880 
14881 	if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14882 		return 0;
14883 	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14884 	if (num < 0)
14885 		return 0;
14886 	for (i = 0; i < num; i++) {
14887 		unsigned int type;
14888 		type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14889 		if (type != AC_WID_AUD_OUT)
14890 			continue;
14891 		for (j = 0; j < spec->multiout.num_dacs; j++)
14892 			if (spec->multiout.dac_nids[j] == srcs[i])
14893 				break;
14894 		if (j >= spec->multiout.num_dacs)
14895 			return srcs[i];
14896 	}
14897 	return 0;
14898 }
14899 
14900 /* fill in the dac_nids table from the parsed pin configuration */
14901 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14902 				     const struct auto_pin_cfg *cfg)
14903 {
14904 	struct alc_spec *spec = codec->spec;
14905 	int i;
14906 	hda_nid_t nid, dac;
14907 
14908 	spec->multiout.dac_nids = spec->private_dac_nids;
14909 	for (i = 0; i < cfg->line_outs; i++) {
14910 		nid = cfg->line_out_pins[i];
14911 		dac = alc861_look_for_dac(codec, nid);
14912 		if (!dac)
14913 			continue;
14914 		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14915 	}
14916 	return 0;
14917 }
14918 
14919 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14920 				hda_nid_t nid, unsigned int chs)
14921 {
14922 	return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14923 			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14924 }
14925 
14926 /* add playback controls from the parsed DAC table */
14927 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14928 					     const struct auto_pin_cfg *cfg)
14929 {
14930 	struct alc_spec *spec = codec->spec;
14931 	static const char *chname[4] = {
14932 		"Front", "Surround", NULL /*CLFE*/, "Side"
14933 	};
14934 	hda_nid_t nid;
14935 	int i, err;
14936 
14937 	if (cfg->line_outs == 1) {
14938 		const char *pfx = NULL;
14939 		if (!cfg->hp_outs)
14940 			pfx = "Master";
14941 		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14942 			pfx = "Speaker";
14943 		if (pfx) {
14944 			nid = spec->multiout.dac_nids[0];
14945 			return alc861_create_out_sw(codec, pfx, nid, 3);
14946 		}
14947 	}
14948 
14949 	for (i = 0; i < cfg->line_outs; i++) {
14950 		nid = spec->multiout.dac_nids[i];
14951 		if (!nid)
14952 			continue;
14953 		if (i == 2) {
14954 			/* Center/LFE */
14955 			err = alc861_create_out_sw(codec, "Center", nid, 1);
14956 			if (err < 0)
14957 				return err;
14958 			err = alc861_create_out_sw(codec, "LFE", nid, 2);
14959 			if (err < 0)
14960 				return err;
14961 		} else {
14962 			err = alc861_create_out_sw(codec, chname[i], nid, 3);
14963 			if (err < 0)
14964 				return err;
14965 		}
14966 	}
14967 	return 0;
14968 }
14969 
14970 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14971 {
14972 	struct alc_spec *spec = codec->spec;
14973 	int err;
14974 	hda_nid_t nid;
14975 
14976 	if (!pin)
14977 		return 0;
14978 
14979 	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14980 		nid = alc861_look_for_dac(codec, pin);
14981 		if (nid) {
14982 			err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14983 			if (err < 0)
14984 				return err;
14985 			spec->multiout.hp_nid = nid;
14986 		}
14987 	}
14988 	return 0;
14989 }
14990 
14991 /* create playback/capture controls for input pins */
14992 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14993 						const struct auto_pin_cfg *cfg)
14994 {
14995 	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14996 }
14997 
14998 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14999 					      hda_nid_t nid,
15000 					      int pin_type, hda_nid_t dac)
15001 {
15002 	hda_nid_t mix, srcs[5];
15003 	int i, num;
15004 
15005 	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15006 			    pin_type);
15007 	snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15008 			    AMP_OUT_UNMUTE);
15009 	if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15010 		return;
15011 	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15012 	if (num < 0)
15013 		return;
15014 	for (i = 0; i < num; i++) {
15015 		unsigned int mute;
15016 		if (srcs[i] == dac || srcs[i] == 0x15)
15017 			mute = AMP_IN_UNMUTE(i);
15018 		else
15019 			mute = AMP_IN_MUTE(i);
15020 		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15021 				    mute);
15022 	}
15023 }
15024 
15025 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15026 {
15027 	struct alc_spec *spec = codec->spec;
15028 	int i;
15029 
15030 	for (i = 0; i < spec->autocfg.line_outs; i++) {
15031 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
15032 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
15033 		if (nid)
15034 			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15035 							  spec->multiout.dac_nids[i]);
15036 	}
15037 }
15038 
15039 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15040 {
15041 	struct alc_spec *spec = codec->spec;
15042 
15043 	if (spec->autocfg.hp_outs)
15044 		alc861_auto_set_output_and_unmute(codec,
15045 						  spec->autocfg.hp_pins[0],
15046 						  PIN_HP,
15047 						  spec->multiout.hp_nid);
15048 	if (spec->autocfg.speaker_outs)
15049 		alc861_auto_set_output_and_unmute(codec,
15050 						  spec->autocfg.speaker_pins[0],
15051 						  PIN_OUT,
15052 						  spec->multiout.dac_nids[0]);
15053 }
15054 
15055 static void alc861_auto_init_analog_input(struct hda_codec *codec)
15056 {
15057 	struct alc_spec *spec = codec->spec;
15058 	int i;
15059 
15060 	for (i = 0; i < AUTO_PIN_LAST; i++) {
15061 		hda_nid_t nid = spec->autocfg.input_pins[i];
15062 		if (nid >= 0x0c && nid <= 0x11)
15063 			alc_set_input_pin(codec, nid, i);
15064 	}
15065 }
15066 
15067 /* parse the BIOS configuration and set up the alc_spec */
15068 /* return 1 if successful, 0 if the proper config is not found,
15069  * or a negative error code
15070  */
15071 static int alc861_parse_auto_config(struct hda_codec *codec)
15072 {
15073 	struct alc_spec *spec = codec->spec;
15074 	int err;
15075 	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15076 
15077 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15078 					   alc861_ignore);
15079 	if (err < 0)
15080 		return err;
15081 	if (!spec->autocfg.line_outs)
15082 		return 0; /* can't find valid BIOS pin config */
15083 
15084 	err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15085 	if (err < 0)
15086 		return err;
15087 	err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15088 	if (err < 0)
15089 		return err;
15090 	err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15091 	if (err < 0)
15092 		return err;
15093 	err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15094 	if (err < 0)
15095 		return err;
15096 
15097 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15098 
15099 	if (spec->autocfg.dig_outs)
15100 		spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
15101 
15102 	if (spec->kctls.list)
15103 		add_mixer(spec, spec->kctls.list);
15104 
15105 	add_verb(spec, alc861_auto_init_verbs);
15106 
15107 	spec->num_mux_defs = 1;
15108 	spec->input_mux = &spec->private_imux[0];
15109 
15110 	spec->adc_nids = alc861_adc_nids;
15111 	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15112 	set_capture_mixer(codec);
15113 
15114 	alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15115 
15116 	return 1;
15117 }
15118 
15119 /* additional initialization for auto-configuration model */
15120 static void alc861_auto_init(struct hda_codec *codec)
15121 {
15122 	struct alc_spec *spec = codec->spec;
15123 	alc861_auto_init_multi_out(codec);
15124 	alc861_auto_init_hp_out(codec);
15125 	alc861_auto_init_analog_input(codec);
15126 	if (spec->unsol_event)
15127 		alc_inithook(codec);
15128 }
15129 
15130 #ifdef CONFIG_SND_HDA_POWER_SAVE
15131 static struct hda_amp_list alc861_loopbacks[] = {
15132 	{ 0x15, HDA_INPUT, 0 },
15133 	{ 0x15, HDA_INPUT, 1 },
15134 	{ 0x15, HDA_INPUT, 2 },
15135 	{ 0x15, HDA_INPUT, 3 },
15136 	{ } /* end */
15137 };
15138 #endif
15139 
15140 
15141 /*
15142  * configuration and preset
15143  */
15144 static const char *alc861_models[ALC861_MODEL_LAST] = {
15145 	[ALC861_3ST]		= "3stack",
15146 	[ALC660_3ST]		= "3stack-660",
15147 	[ALC861_3ST_DIG]	= "3stack-dig",
15148 	[ALC861_6ST_DIG]	= "6stack-dig",
15149 	[ALC861_UNIWILL_M31]	= "uniwill-m31",
15150 	[ALC861_TOSHIBA]	= "toshiba",
15151 	[ALC861_ASUS]		= "asus",
15152 	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
15153 	[ALC861_AUTO]		= "auto",
15154 };
15155 
15156 static struct snd_pci_quirk alc861_cfg_tbl[] = {
15157 	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15158 	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15159 	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15160 	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15161 	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15162 	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
15163 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
15164 	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
15165 	 *        Any other models that need this preset?
15166 	 */
15167 	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
15168 	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
15169 	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
15170 	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
15171 	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
15172 	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
15173 	/* FIXME: the below seems conflict */
15174 	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
15175 	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
15176 	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
15177 	{}
15178 };
15179 
15180 static struct alc_config_preset alc861_presets[] = {
15181 	[ALC861_3ST] = {
15182 		.mixers = { alc861_3ST_mixer },
15183 		.init_verbs = { alc861_threestack_init_verbs },
15184 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15185 		.dac_nids = alc861_dac_nids,
15186 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15187 		.channel_mode = alc861_threestack_modes,
15188 		.need_dac_fix = 1,
15189 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15190 		.adc_nids = alc861_adc_nids,
15191 		.input_mux = &alc861_capture_source,
15192 	},
15193 	[ALC861_3ST_DIG] = {
15194 		.mixers = { alc861_base_mixer },
15195 		.init_verbs = { alc861_threestack_init_verbs },
15196 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15197 		.dac_nids = alc861_dac_nids,
15198 		.dig_out_nid = ALC861_DIGOUT_NID,
15199 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15200 		.channel_mode = alc861_threestack_modes,
15201 		.need_dac_fix = 1,
15202 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15203 		.adc_nids = alc861_adc_nids,
15204 		.input_mux = &alc861_capture_source,
15205 	},
15206 	[ALC861_6ST_DIG] = {
15207 		.mixers = { alc861_base_mixer },
15208 		.init_verbs = { alc861_base_init_verbs },
15209 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15210 		.dac_nids = alc861_dac_nids,
15211 		.dig_out_nid = ALC861_DIGOUT_NID,
15212 		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
15213 		.channel_mode = alc861_8ch_modes,
15214 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15215 		.adc_nids = alc861_adc_nids,
15216 		.input_mux = &alc861_capture_source,
15217 	},
15218 	[ALC660_3ST] = {
15219 		.mixers = { alc861_3ST_mixer },
15220 		.init_verbs = { alc861_threestack_init_verbs },
15221 		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
15222 		.dac_nids = alc660_dac_nids,
15223 		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15224 		.channel_mode = alc861_threestack_modes,
15225 		.need_dac_fix = 1,
15226 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15227 		.adc_nids = alc861_adc_nids,
15228 		.input_mux = &alc861_capture_source,
15229 	},
15230 	[ALC861_UNIWILL_M31] = {
15231 		.mixers = { alc861_uniwill_m31_mixer },
15232 		.init_verbs = { alc861_uniwill_m31_init_verbs },
15233 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15234 		.dac_nids = alc861_dac_nids,
15235 		.dig_out_nid = ALC861_DIGOUT_NID,
15236 		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
15237 		.channel_mode = alc861_uniwill_m31_modes,
15238 		.need_dac_fix = 1,
15239 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15240 		.adc_nids = alc861_adc_nids,
15241 		.input_mux = &alc861_capture_source,
15242 	},
15243 	[ALC861_TOSHIBA] = {
15244 		.mixers = { alc861_toshiba_mixer },
15245 		.init_verbs = { alc861_base_init_verbs,
15246 				alc861_toshiba_init_verbs },
15247 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15248 		.dac_nids = alc861_dac_nids,
15249 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15250 		.channel_mode = alc883_3ST_2ch_modes,
15251 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15252 		.adc_nids = alc861_adc_nids,
15253 		.input_mux = &alc861_capture_source,
15254 		.unsol_event = alc861_toshiba_unsol_event,
15255 		.init_hook = alc861_toshiba_automute,
15256 	},
15257 	[ALC861_ASUS] = {
15258 		.mixers = { alc861_asus_mixer },
15259 		.init_verbs = { alc861_asus_init_verbs },
15260 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15261 		.dac_nids = alc861_dac_nids,
15262 		.dig_out_nid = ALC861_DIGOUT_NID,
15263 		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
15264 		.channel_mode = alc861_asus_modes,
15265 		.need_dac_fix = 1,
15266 		.hp_nid = 0x06,
15267 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15268 		.adc_nids = alc861_adc_nids,
15269 		.input_mux = &alc861_capture_source,
15270 	},
15271 	[ALC861_ASUS_LAPTOP] = {
15272 		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
15273 		.init_verbs = { alc861_asus_init_verbs,
15274 				alc861_asus_laptop_init_verbs },
15275 		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
15276 		.dac_nids = alc861_dac_nids,
15277 		.dig_out_nid = ALC861_DIGOUT_NID,
15278 		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15279 		.channel_mode = alc883_3ST_2ch_modes,
15280 		.need_dac_fix = 1,
15281 		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15282 		.adc_nids = alc861_adc_nids,
15283 		.input_mux = &alc861_capture_source,
15284 	},
15285 };
15286 
15287 /* Pin config fixes */
15288 enum {
15289 	PINFIX_FSC_AMILO_PI1505,
15290 };
15291 
15292 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
15293 	{ 0x0b, 0x0221101f }, /* HP */
15294 	{ 0x0f, 0x90170310 }, /* speaker */
15295 	{ }
15296 };
15297 
15298 static const struct alc_fixup alc861_fixups[] = {
15299 	[PINFIX_FSC_AMILO_PI1505] = {
15300 		.pins = alc861_fsc_amilo_pi1505_pinfix
15301 	},
15302 };
15303 
15304 static struct snd_pci_quirk alc861_fixup_tbl[] = {
15305 	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
15306 	{}
15307 };
15308 
15309 static int patch_alc861(struct hda_codec *codec)
15310 {
15311 	struct alc_spec *spec;
15312 	int board_config;
15313 	int err;
15314 
15315 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15316 	if (spec == NULL)
15317 		return -ENOMEM;
15318 
15319 	codec->spec = spec;
15320 
15321         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
15322 						  alc861_models,
15323 						  alc861_cfg_tbl);
15324 
15325 	if (board_config < 0) {
15326 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15327 		       codec->chip_name);
15328 		board_config = ALC861_AUTO;
15329 	}
15330 
15331 	alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
15332 
15333 	if (board_config == ALC861_AUTO) {
15334 		/* automatic parse from the BIOS config */
15335 		err = alc861_parse_auto_config(codec);
15336 		if (err < 0) {
15337 			alc_free(codec);
15338 			return err;
15339 		} else if (!err) {
15340 			printk(KERN_INFO
15341 			       "hda_codec: Cannot set up configuration "
15342 			       "from BIOS.  Using base mode...\n");
15343 		   board_config = ALC861_3ST_DIG;
15344 		}
15345 	}
15346 
15347 	err = snd_hda_attach_beep_device(codec, 0x23);
15348 	if (err < 0) {
15349 		alc_free(codec);
15350 		return err;
15351 	}
15352 
15353 	if (board_config != ALC861_AUTO)
15354 		setup_preset(codec, &alc861_presets[board_config]);
15355 
15356 	spec->stream_analog_playback = &alc861_pcm_analog_playback;
15357 	spec->stream_analog_capture = &alc861_pcm_analog_capture;
15358 
15359 	spec->stream_digital_playback = &alc861_pcm_digital_playback;
15360 	spec->stream_digital_capture = &alc861_pcm_digital_capture;
15361 
15362 	if (!spec->cap_mixer)
15363 		set_capture_mixer(codec);
15364 	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
15365 
15366 	spec->vmaster_nid = 0x03;
15367 
15368 	codec->patch_ops = alc_patch_ops;
15369 	if (board_config == ALC861_AUTO) {
15370 		spec->init_hook = alc861_auto_init;
15371 #ifdef CONFIG_SND_HDA_POWER_SAVE
15372 		spec->power_hook = alc_power_eapd;
15373 #endif
15374 	}
15375 #ifdef CONFIG_SND_HDA_POWER_SAVE
15376 	if (!spec->loopback.amplist)
15377 		spec->loopback.amplist = alc861_loopbacks;
15378 #endif
15379 
15380 	return 0;
15381 }
15382 
15383 /*
15384  * ALC861-VD support
15385  *
15386  * Based on ALC882
15387  *
15388  * In addition, an independent DAC
15389  */
15390 #define ALC861VD_DIGOUT_NID	0x06
15391 
15392 static hda_nid_t alc861vd_dac_nids[4] = {
15393 	/* front, surr, clfe, side surr */
15394 	0x02, 0x03, 0x04, 0x05
15395 };
15396 
15397 /* dac_nids for ALC660vd are in a different order - according to
15398  * Realtek's driver.
15399  * This should probably result in a different mixer for 6stack models
15400  * of ALC660vd codecs, but for now there is only 3stack mixer
15401  * - and it is the same as in 861vd.
15402  * adc_nids in ALC660vd are (is) the same as in 861vd
15403  */
15404 static hda_nid_t alc660vd_dac_nids[3] = {
15405 	/* front, rear, clfe, rear_surr */
15406 	0x02, 0x04, 0x03
15407 };
15408 
15409 static hda_nid_t alc861vd_adc_nids[1] = {
15410 	/* ADC0 */
15411 	0x09,
15412 };
15413 
15414 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
15415 
15416 /* input MUX */
15417 /* FIXME: should be a matrix-type input source selection */
15418 static struct hda_input_mux alc861vd_capture_source = {
15419 	.num_items = 4,
15420 	.items = {
15421 		{ "Mic", 0x0 },
15422 		{ "Front Mic", 0x1 },
15423 		{ "Line", 0x2 },
15424 		{ "CD", 0x4 },
15425 	},
15426 };
15427 
15428 static struct hda_input_mux alc861vd_dallas_capture_source = {
15429 	.num_items = 2,
15430 	.items = {
15431 		{ "Ext Mic", 0x0 },
15432 		{ "Int Mic", 0x1 },
15433 	},
15434 };
15435 
15436 static struct hda_input_mux alc861vd_hp_capture_source = {
15437 	.num_items = 2,
15438 	.items = {
15439 		{ "Front Mic", 0x0 },
15440 		{ "ATAPI Mic", 0x1 },
15441 	},
15442 };
15443 
15444 /*
15445  * 2ch mode
15446  */
15447 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
15448 	{ 2, NULL }
15449 };
15450 
15451 /*
15452  * 6ch mode
15453  */
15454 static struct hda_verb alc861vd_6stack_ch6_init[] = {
15455 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15456 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15457 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15458 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15459 	{ } /* end */
15460 };
15461 
15462 /*
15463  * 8ch mode
15464  */
15465 static struct hda_verb alc861vd_6stack_ch8_init[] = {
15466 	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15467 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15468 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15469 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15470 	{ } /* end */
15471 };
15472 
15473 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
15474 	{ 6, alc861vd_6stack_ch6_init },
15475 	{ 8, alc861vd_6stack_ch8_init },
15476 };
15477 
15478 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
15479 	{
15480 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15481 		.name = "Channel Mode",
15482 		.info = alc_ch_mode_info,
15483 		.get = alc_ch_mode_get,
15484 		.put = alc_ch_mode_put,
15485 	},
15486 	{ } /* end */
15487 };
15488 
15489 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15490  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15491  */
15492 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
15493 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15494 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15495 
15496 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15497 	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
15498 
15499 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
15500 				HDA_OUTPUT),
15501 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
15502 				HDA_OUTPUT),
15503 	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
15504 	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
15505 
15506 	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15507 	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15508 
15509 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15510 
15511 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15512 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15513 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15514 
15515 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15516 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15517 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15518 
15519 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15520 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15521 
15522 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15523 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15524 
15525 	{ } /* end */
15526 };
15527 
15528 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15529 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15530 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15531 
15532 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15533 
15534 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15535 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15536 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15537 
15538 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15539 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15540 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15541 
15542 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15543 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15544 
15545 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15546 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15547 
15548 	{ } /* end */
15549 };
15550 
15551 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15552 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15553 	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15554 	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15555 
15556 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15557 
15558 	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15559 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15560 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15561 
15562 	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15563 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15564 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15565 
15566 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15567 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15568 
15569 	{ } /* end */
15570 };
15571 
15572 /* Pin assignment: Speaker=0x14, HP = 0x15,
15573  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15574  */
15575 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15576 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15577 	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15578 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15579 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15580 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15581 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15582 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15583 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15584 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15585 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15586 	{ } /* end */
15587 };
15588 
15589 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15590  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15591  */
15592 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15593 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15594 	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15595 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15596 	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15597 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15598 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15599 	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15600 	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15601 
15602 	{ } /* end */
15603 };
15604 
15605 /*
15606  * generic initialization of ADC, input mixers and output mixers
15607  */
15608 static struct hda_verb alc861vd_volume_init_verbs[] = {
15609 	/*
15610 	 * Unmute ADC0 and set the default input to mic-in
15611 	 */
15612 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15613 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15614 
15615 	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15616 	 * the analog-loopback mixer widget
15617 	 */
15618 	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15619 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15620 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15621 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15622 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15623 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15624 
15625 	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15626 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15627 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15628 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15629 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15630 
15631 	/*
15632 	 * Set up output mixers (0x02 - 0x05)
15633 	 */
15634 	/* set vol=0 to output mixers */
15635 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15636 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15637 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15638 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15639 
15640 	/* set up input amps for analog loopback */
15641 	/* Amp Indices: DAC = 0, mixer = 1 */
15642 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15643 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15644 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15645 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15646 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15647 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15648 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15649 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15650 
15651 	{ }
15652 };
15653 
15654 /*
15655  * 3-stack pin configuration:
15656  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15657  */
15658 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15659 	/*
15660 	 * Set pin mode and muting
15661 	 */
15662 	/* set front pin widgets 0x14 for output */
15663 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15664 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15665 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15666 
15667 	/* Mic (rear) pin: input vref at 80% */
15668 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15669 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15670 	/* Front Mic pin: input vref at 80% */
15671 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15672 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15673 	/* Line In pin: input */
15674 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15675 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15676 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
15677 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15678 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15679 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15680 	/* CD pin widget for input */
15681 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15682 
15683 	{ }
15684 };
15685 
15686 /*
15687  * 6-stack pin configuration:
15688  */
15689 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15690 	/*
15691 	 * Set pin mode and muting
15692 	 */
15693 	/* set front pin widgets 0x14 for output */
15694 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15695 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15696 	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15697 
15698 	/* Rear Pin: output 1 (0x0d) */
15699 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15700 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15701 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15702 	/* CLFE Pin: output 2 (0x0e) */
15703 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15704 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15705 	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15706 	/* Side Pin: output 3 (0x0f) */
15707 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15708 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15709 	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15710 
15711 	/* Mic (rear) pin: input vref at 80% */
15712 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15713 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15714 	/* Front Mic pin: input vref at 80% */
15715 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15716 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15717 	/* Line In pin: input */
15718 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15719 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15720 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
15721 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15722 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15723 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15724 	/* CD pin widget for input */
15725 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15726 
15727 	{ }
15728 };
15729 
15730 static struct hda_verb alc861vd_eapd_verbs[] = {
15731 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15732 	{ }
15733 };
15734 
15735 static struct hda_verb alc660vd_eapd_verbs[] = {
15736 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15737 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15738 	{ }
15739 };
15740 
15741 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15742 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15743 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15744 	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15745 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15746 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15747 	{}
15748 };
15749 
15750 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15751 {
15752 	unsigned int present;
15753 	unsigned char bits;
15754 
15755 	present = snd_hda_jack_detect(codec, 0x18);
15756 	bits = present ? HDA_AMP_MUTE : 0;
15757 
15758 	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15759 				 HDA_AMP_MUTE, bits);
15760 }
15761 
15762 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15763 {
15764 	struct alc_spec *spec = codec->spec;
15765 	spec->autocfg.hp_pins[0] = 0x1b;
15766 	spec->autocfg.speaker_pins[0] = 0x14;
15767 }
15768 
15769 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15770 {
15771 	alc_automute_amp(codec);
15772 	alc861vd_lenovo_mic_automute(codec);
15773 }
15774 
15775 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15776 					unsigned int res)
15777 {
15778 	switch (res >> 26) {
15779 	case ALC880_MIC_EVENT:
15780 		alc861vd_lenovo_mic_automute(codec);
15781 		break;
15782 	default:
15783 		alc_automute_amp_unsol_event(codec, res);
15784 		break;
15785 	}
15786 }
15787 
15788 static struct hda_verb alc861vd_dallas_verbs[] = {
15789 	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15790 	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15791 	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15792 	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15793 
15794 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15795 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15796 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15797 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15798 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15799 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15800 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15801 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15802 
15803 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15804 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15805 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15806 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15807 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15808 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15809 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15810 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15811 
15812 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15813 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15814 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15815 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15816 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15817 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15818 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15819 	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15820 
15821 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15822 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15823 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15824 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15825 
15826 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15827 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15828 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15829 
15830 	{ } /* end */
15831 };
15832 
15833 /* toggle speaker-output according to the hp-jack state */
15834 static void alc861vd_dallas_setup(struct hda_codec *codec)
15835 {
15836 	struct alc_spec *spec = codec->spec;
15837 
15838 	spec->autocfg.hp_pins[0] = 0x15;
15839 	spec->autocfg.speaker_pins[0] = 0x14;
15840 }
15841 
15842 #ifdef CONFIG_SND_HDA_POWER_SAVE
15843 #define alc861vd_loopbacks	alc880_loopbacks
15844 #endif
15845 
15846 /* pcm configuration: identical with ALC880 */
15847 #define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
15848 #define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
15849 #define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
15850 #define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
15851 
15852 /*
15853  * configuration and preset
15854  */
15855 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15856 	[ALC660VD_3ST]		= "3stack-660",
15857 	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
15858 	[ALC660VD_ASUS_V1S]	= "asus-v1s",
15859 	[ALC861VD_3ST]		= "3stack",
15860 	[ALC861VD_3ST_DIG]	= "3stack-digout",
15861 	[ALC861VD_6ST_DIG]	= "6stack-digout",
15862 	[ALC861VD_LENOVO]	= "lenovo",
15863 	[ALC861VD_DALLAS]	= "dallas",
15864 	[ALC861VD_HP]		= "hp",
15865 	[ALC861VD_AUTO]		= "auto",
15866 };
15867 
15868 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15869 	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15870 	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15871 	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15872 	/*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15873 	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15874 	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15875 	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15876 	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15877 	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15878 	SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15879 	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15880 	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15881 	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15882 	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15883 	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15884 	{}
15885 };
15886 
15887 static struct alc_config_preset alc861vd_presets[] = {
15888 	[ALC660VD_3ST] = {
15889 		.mixers = { alc861vd_3st_mixer },
15890 		.init_verbs = { alc861vd_volume_init_verbs,
15891 				 alc861vd_3stack_init_verbs },
15892 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15893 		.dac_nids = alc660vd_dac_nids,
15894 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15895 		.channel_mode = alc861vd_3stack_2ch_modes,
15896 		.input_mux = &alc861vd_capture_source,
15897 	},
15898 	[ALC660VD_3ST_DIG] = {
15899 		.mixers = { alc861vd_3st_mixer },
15900 		.init_verbs = { alc861vd_volume_init_verbs,
15901 				 alc861vd_3stack_init_verbs },
15902 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15903 		.dac_nids = alc660vd_dac_nids,
15904 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15905 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15906 		.channel_mode = alc861vd_3stack_2ch_modes,
15907 		.input_mux = &alc861vd_capture_source,
15908 	},
15909 	[ALC861VD_3ST] = {
15910 		.mixers = { alc861vd_3st_mixer },
15911 		.init_verbs = { alc861vd_volume_init_verbs,
15912 				 alc861vd_3stack_init_verbs },
15913 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15914 		.dac_nids = alc861vd_dac_nids,
15915 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15916 		.channel_mode = alc861vd_3stack_2ch_modes,
15917 		.input_mux = &alc861vd_capture_source,
15918 	},
15919 	[ALC861VD_3ST_DIG] = {
15920 		.mixers = { alc861vd_3st_mixer },
15921 		.init_verbs = { alc861vd_volume_init_verbs,
15922 		 		 alc861vd_3stack_init_verbs },
15923 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15924 		.dac_nids = alc861vd_dac_nids,
15925 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15926 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15927 		.channel_mode = alc861vd_3stack_2ch_modes,
15928 		.input_mux = &alc861vd_capture_source,
15929 	},
15930 	[ALC861VD_6ST_DIG] = {
15931 		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15932 		.init_verbs = { alc861vd_volume_init_verbs,
15933 				alc861vd_6stack_init_verbs },
15934 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15935 		.dac_nids = alc861vd_dac_nids,
15936 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15937 		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15938 		.channel_mode = alc861vd_6stack_modes,
15939 		.input_mux = &alc861vd_capture_source,
15940 	},
15941 	[ALC861VD_LENOVO] = {
15942 		.mixers = { alc861vd_lenovo_mixer },
15943 		.init_verbs = { alc861vd_volume_init_verbs,
15944 				alc861vd_3stack_init_verbs,
15945 				alc861vd_eapd_verbs,
15946 				alc861vd_lenovo_unsol_verbs },
15947 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15948 		.dac_nids = alc660vd_dac_nids,
15949 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15950 		.channel_mode = alc861vd_3stack_2ch_modes,
15951 		.input_mux = &alc861vd_capture_source,
15952 		.unsol_event = alc861vd_lenovo_unsol_event,
15953 		.setup = alc861vd_lenovo_setup,
15954 		.init_hook = alc861vd_lenovo_init_hook,
15955 	},
15956 	[ALC861VD_DALLAS] = {
15957 		.mixers = { alc861vd_dallas_mixer },
15958 		.init_verbs = { alc861vd_dallas_verbs },
15959 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15960 		.dac_nids = alc861vd_dac_nids,
15961 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15962 		.channel_mode = alc861vd_3stack_2ch_modes,
15963 		.input_mux = &alc861vd_dallas_capture_source,
15964 		.unsol_event = alc_automute_amp_unsol_event,
15965 		.setup = alc861vd_dallas_setup,
15966 		.init_hook = alc_automute_amp,
15967 	},
15968 	[ALC861VD_HP] = {
15969 		.mixers = { alc861vd_hp_mixer },
15970 		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15971 		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15972 		.dac_nids = alc861vd_dac_nids,
15973 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15974 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15975 		.channel_mode = alc861vd_3stack_2ch_modes,
15976 		.input_mux = &alc861vd_hp_capture_source,
15977 		.unsol_event = alc_automute_amp_unsol_event,
15978 		.setup = alc861vd_dallas_setup,
15979 		.init_hook = alc_automute_amp,
15980 	},
15981 	[ALC660VD_ASUS_V1S] = {
15982 		.mixers = { alc861vd_lenovo_mixer },
15983 		.init_verbs = { alc861vd_volume_init_verbs,
15984 				alc861vd_3stack_init_verbs,
15985 				alc861vd_eapd_verbs,
15986 				alc861vd_lenovo_unsol_verbs },
15987 		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15988 		.dac_nids = alc660vd_dac_nids,
15989 		.dig_out_nid = ALC861VD_DIGOUT_NID,
15990 		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15991 		.channel_mode = alc861vd_3stack_2ch_modes,
15992 		.input_mux = &alc861vd_capture_source,
15993 		.unsol_event = alc861vd_lenovo_unsol_event,
15994 		.setup = alc861vd_lenovo_setup,
15995 		.init_hook = alc861vd_lenovo_init_hook,
15996 	},
15997 };
15998 
15999 /*
16000  * BIOS auto configuration
16001  */
16002 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16003 						const struct auto_pin_cfg *cfg)
16004 {
16005 	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16006 }
16007 
16008 
16009 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16010 				hda_nid_t nid, int pin_type, int dac_idx)
16011 {
16012 	alc_set_pin_output(codec, nid, pin_type);
16013 }
16014 
16015 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16016 {
16017 	struct alc_spec *spec = codec->spec;
16018 	int i;
16019 
16020 	for (i = 0; i <= HDA_SIDE; i++) {
16021 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16022 		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16023 		if (nid)
16024 			alc861vd_auto_set_output_and_unmute(codec, nid,
16025 							    pin_type, i);
16026 	}
16027 }
16028 
16029 
16030 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16031 {
16032 	struct alc_spec *spec = codec->spec;
16033 	hda_nid_t pin;
16034 
16035 	pin = spec->autocfg.hp_pins[0];
16036 	if (pin) /* connect to front and use dac 0 */
16037 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16038 	pin = spec->autocfg.speaker_pins[0];
16039 	if (pin)
16040 		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16041 }
16042 
16043 #define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
16044 
16045 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16046 {
16047 	struct alc_spec *spec = codec->spec;
16048 	int i;
16049 
16050 	for (i = 0; i < AUTO_PIN_LAST; i++) {
16051 		hda_nid_t nid = spec->autocfg.input_pins[i];
16052 		if (alc_is_input_pin(codec, nid)) {
16053 			alc_set_input_pin(codec, nid, i);
16054 			if (nid != ALC861VD_PIN_CD_NID &&
16055 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16056 				snd_hda_codec_write(codec, nid, 0,
16057 						AC_VERB_SET_AMP_GAIN_MUTE,
16058 						AMP_OUT_MUTE);
16059 		}
16060 	}
16061 }
16062 
16063 #define alc861vd_auto_init_input_src	alc882_auto_init_input_src
16064 
16065 #define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
16066 #define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
16067 
16068 /* add playback controls from the parsed DAC table */
16069 /* Based on ALC880 version. But ALC861VD has separate,
16070  * different NIDs for mute/unmute switch and volume control */
16071 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16072 					     const struct auto_pin_cfg *cfg)
16073 {
16074 	static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16075 	hda_nid_t nid_v, nid_s;
16076 	int i, err;
16077 
16078 	for (i = 0; i < cfg->line_outs; i++) {
16079 		if (!spec->multiout.dac_nids[i])
16080 			continue;
16081 		nid_v = alc861vd_idx_to_mixer_vol(
16082 				alc880_dac_to_idx(
16083 					spec->multiout.dac_nids[i]));
16084 		nid_s = alc861vd_idx_to_mixer_switch(
16085 				alc880_dac_to_idx(
16086 					spec->multiout.dac_nids[i]));
16087 
16088 		if (i == 2) {
16089 			/* Center/LFE */
16090 			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16091 					      "Center",
16092 					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16093 							      HDA_OUTPUT));
16094 			if (err < 0)
16095 				return err;
16096 			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16097 					      "LFE",
16098 					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16099 							      HDA_OUTPUT));
16100 			if (err < 0)
16101 				return err;
16102 			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16103 					     "Center",
16104 					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16105 							      HDA_INPUT));
16106 			if (err < 0)
16107 				return err;
16108 			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16109 					     "LFE",
16110 					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16111 							      HDA_INPUT));
16112 			if (err < 0)
16113 				return err;
16114 		} else {
16115 			const char *pfx;
16116 			if (cfg->line_outs == 1 &&
16117 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16118 				if (!cfg->hp_pins)
16119 					pfx = "Speaker";
16120 				else
16121 					pfx = "PCM";
16122 			} else
16123 				pfx = chname[i];
16124 			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16125 					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16126 							      HDA_OUTPUT));
16127 			if (err < 0)
16128 				return err;
16129 			if (cfg->line_outs == 1 &&
16130 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16131 				pfx = "Speaker";
16132 			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16133 					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16134 							      HDA_INPUT));
16135 			if (err < 0)
16136 				return err;
16137 		}
16138 	}
16139 	return 0;
16140 }
16141 
16142 /* add playback controls for speaker and HP outputs */
16143 /* Based on ALC880 version. But ALC861VD has separate,
16144  * different NIDs for mute/unmute switch and volume control */
16145 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16146 					hda_nid_t pin, const char *pfx)
16147 {
16148 	hda_nid_t nid_v, nid_s;
16149 	int err;
16150 
16151 	if (!pin)
16152 		return 0;
16153 
16154 	if (alc880_is_fixed_pin(pin)) {
16155 		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16156 		/* specify the DAC as the extra output */
16157 		if (!spec->multiout.hp_nid)
16158 			spec->multiout.hp_nid = nid_v;
16159 		else
16160 			spec->multiout.extra_out_nid[0] = nid_v;
16161 		/* control HP volume/switch on the output mixer amp */
16162 		nid_v = alc861vd_idx_to_mixer_vol(
16163 				alc880_fixed_pin_idx(pin));
16164 		nid_s = alc861vd_idx_to_mixer_switch(
16165 				alc880_fixed_pin_idx(pin));
16166 
16167 		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16168 				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
16169 		if (err < 0)
16170 			return err;
16171 		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16172 				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
16173 		if (err < 0)
16174 			return err;
16175 	} else if (alc880_is_multi_pin(pin)) {
16176 		/* set manual connection */
16177 		/* we have only a switch on HP-out PIN */
16178 		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
16179 				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16180 		if (err < 0)
16181 			return err;
16182 	}
16183 	return 0;
16184 }
16185 
16186 /* parse the BIOS configuration and set up the alc_spec
16187  * return 1 if successful, 0 if the proper config is not found,
16188  * or a negative error code
16189  * Based on ALC880 version - had to change it to override
16190  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
16191 static int alc861vd_parse_auto_config(struct hda_codec *codec)
16192 {
16193 	struct alc_spec *spec = codec->spec;
16194 	int err;
16195 	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
16196 
16197 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16198 					   alc861vd_ignore);
16199 	if (err < 0)
16200 		return err;
16201 	if (!spec->autocfg.line_outs)
16202 		return 0; /* can't find valid BIOS pin config */
16203 
16204 	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16205 	if (err < 0)
16206 		return err;
16207 	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
16208 	if (err < 0)
16209 		return err;
16210 	err = alc861vd_auto_create_extra_out(spec,
16211 					     spec->autocfg.speaker_pins[0],
16212 					     "Speaker");
16213 	if (err < 0)
16214 		return err;
16215 	err = alc861vd_auto_create_extra_out(spec,
16216 					     spec->autocfg.hp_pins[0],
16217 					     "Headphone");
16218 	if (err < 0)
16219 		return err;
16220 	err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
16221 	if (err < 0)
16222 		return err;
16223 
16224 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16225 
16226 	if (spec->autocfg.dig_outs)
16227 		spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
16228 
16229 	if (spec->kctls.list)
16230 		add_mixer(spec, spec->kctls.list);
16231 
16232 	add_verb(spec, alc861vd_volume_init_verbs);
16233 
16234 	spec->num_mux_defs = 1;
16235 	spec->input_mux = &spec->private_imux[0];
16236 
16237 	err = alc_auto_add_mic_boost(codec);
16238 	if (err < 0)
16239 		return err;
16240 
16241 	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
16242 
16243 	return 1;
16244 }
16245 
16246 /* additional initialization for auto-configuration model */
16247 static void alc861vd_auto_init(struct hda_codec *codec)
16248 {
16249 	struct alc_spec *spec = codec->spec;
16250 	alc861vd_auto_init_multi_out(codec);
16251 	alc861vd_auto_init_hp_out(codec);
16252 	alc861vd_auto_init_analog_input(codec);
16253 	alc861vd_auto_init_input_src(codec);
16254 	if (spec->unsol_event)
16255 		alc_inithook(codec);
16256 }
16257 
16258 enum {
16259 	ALC660VD_FIX_ASUS_GPIO1
16260 };
16261 
16262 /* reset GPIO1 */
16263 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
16264 	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
16265 	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
16266 	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
16267 	{ }
16268 };
16269 
16270 static const struct alc_fixup alc861vd_fixups[] = {
16271 	[ALC660VD_FIX_ASUS_GPIO1] = {
16272 		.verbs = alc660vd_fix_asus_gpio1_verbs,
16273 	},
16274 };
16275 
16276 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
16277 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
16278 	{}
16279 };
16280 
16281 static int patch_alc861vd(struct hda_codec *codec)
16282 {
16283 	struct alc_spec *spec;
16284 	int err, board_config;
16285 
16286 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16287 	if (spec == NULL)
16288 		return -ENOMEM;
16289 
16290 	codec->spec = spec;
16291 
16292 	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
16293 						  alc861vd_models,
16294 						  alc861vd_cfg_tbl);
16295 
16296 	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
16297 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16298 		       codec->chip_name);
16299 		board_config = ALC861VD_AUTO;
16300 	}
16301 
16302 	alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
16303 
16304 	if (board_config == ALC861VD_AUTO) {
16305 		/* automatic parse from the BIOS config */
16306 		err = alc861vd_parse_auto_config(codec);
16307 		if (err < 0) {
16308 			alc_free(codec);
16309 			return err;
16310 		} else if (!err) {
16311 			printk(KERN_INFO
16312 			       "hda_codec: Cannot set up configuration "
16313 			       "from BIOS.  Using base mode...\n");
16314 			board_config = ALC861VD_3ST;
16315 		}
16316 	}
16317 
16318 	err = snd_hda_attach_beep_device(codec, 0x23);
16319 	if (err < 0) {
16320 		alc_free(codec);
16321 		return err;
16322 	}
16323 
16324 	if (board_config != ALC861VD_AUTO)
16325 		setup_preset(codec, &alc861vd_presets[board_config]);
16326 
16327 	if (codec->vendor_id == 0x10ec0660) {
16328 		/* always turn on EAPD */
16329 		add_verb(spec, alc660vd_eapd_verbs);
16330 	}
16331 
16332 	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
16333 	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
16334 
16335 	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
16336 	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
16337 
16338 	if (!spec->adc_nids) {
16339 		spec->adc_nids = alc861vd_adc_nids;
16340 		spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
16341 	}
16342 	if (!spec->capsrc_nids)
16343 		spec->capsrc_nids = alc861vd_capsrc_nids;
16344 
16345 	set_capture_mixer(codec);
16346 	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16347 
16348 	spec->vmaster_nid = 0x02;
16349 
16350 	codec->patch_ops = alc_patch_ops;
16351 
16352 	if (board_config == ALC861VD_AUTO)
16353 		spec->init_hook = alc861vd_auto_init;
16354 #ifdef CONFIG_SND_HDA_POWER_SAVE
16355 	if (!spec->loopback.amplist)
16356 		spec->loopback.amplist = alc861vd_loopbacks;
16357 #endif
16358 
16359 	return 0;
16360 }
16361 
16362 /*
16363  * ALC662 support
16364  *
16365  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
16366  * configuration.  Each pin widget can choose any input DACs and a mixer.
16367  * Each ADC is connected from a mixer of all inputs.  This makes possible
16368  * 6-channel independent captures.
16369  *
16370  * In addition, an independent DAC for the multi-playback (not used in this
16371  * driver yet).
16372  */
16373 #define ALC662_DIGOUT_NID	0x06
16374 #define ALC662_DIGIN_NID	0x0a
16375 
16376 static hda_nid_t alc662_dac_nids[4] = {
16377 	/* front, rear, clfe, rear_surr */
16378 	0x02, 0x03, 0x04
16379 };
16380 
16381 static hda_nid_t alc272_dac_nids[2] = {
16382 	0x02, 0x03
16383 };
16384 
16385 static hda_nid_t alc662_adc_nids[2] = {
16386 	/* ADC1-2 */
16387 	0x09, 0x08
16388 };
16389 
16390 static hda_nid_t alc272_adc_nids[1] = {
16391 	/* ADC1-2 */
16392 	0x08,
16393 };
16394 
16395 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
16396 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
16397 
16398 
16399 /* input MUX */
16400 /* FIXME: should be a matrix-type input source selection */
16401 static struct hda_input_mux alc662_capture_source = {
16402 	.num_items = 4,
16403 	.items = {
16404 		{ "Mic", 0x0 },
16405 		{ "Front Mic", 0x1 },
16406 		{ "Line", 0x2 },
16407 		{ "CD", 0x4 },
16408 	},
16409 };
16410 
16411 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
16412 	.num_items = 2,
16413 	.items = {
16414 		{ "Mic", 0x1 },
16415 		{ "Line", 0x2 },
16416 	},
16417 };
16418 
16419 static struct hda_input_mux alc663_capture_source = {
16420 	.num_items = 3,
16421 	.items = {
16422 		{ "Mic", 0x0 },
16423 		{ "Front Mic", 0x1 },
16424 		{ "Line", 0x2 },
16425 	},
16426 };
16427 
16428 #if 0 /* set to 1 for testing other input sources below */
16429 static struct hda_input_mux alc272_nc10_capture_source = {
16430 	.num_items = 16,
16431 	.items = {
16432 		{ "Autoselect Mic", 0x0 },
16433 		{ "Internal Mic", 0x1 },
16434 		{ "In-0x02", 0x2 },
16435 		{ "In-0x03", 0x3 },
16436 		{ "In-0x04", 0x4 },
16437 		{ "In-0x05", 0x5 },
16438 		{ "In-0x06", 0x6 },
16439 		{ "In-0x07", 0x7 },
16440 		{ "In-0x08", 0x8 },
16441 		{ "In-0x09", 0x9 },
16442 		{ "In-0x0a", 0x0a },
16443 		{ "In-0x0b", 0x0b },
16444 		{ "In-0x0c", 0x0c },
16445 		{ "In-0x0d", 0x0d },
16446 		{ "In-0x0e", 0x0e },
16447 		{ "In-0x0f", 0x0f },
16448 	},
16449 };
16450 #endif
16451 
16452 /*
16453  * 2ch mode
16454  */
16455 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
16456 	{ 2, NULL }
16457 };
16458 
16459 /*
16460  * 2ch mode
16461  */
16462 static struct hda_verb alc662_3ST_ch2_init[] = {
16463 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
16464 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16465 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
16466 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16467 	{ } /* end */
16468 };
16469 
16470 /*
16471  * 6ch mode
16472  */
16473 static struct hda_verb alc662_3ST_ch6_init[] = {
16474 	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16475 	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16476 	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
16477 	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16478 	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16479 	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
16480 	{ } /* end */
16481 };
16482 
16483 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
16484 	{ 2, alc662_3ST_ch2_init },
16485 	{ 6, alc662_3ST_ch6_init },
16486 };
16487 
16488 /*
16489  * 2ch mode
16490  */
16491 static struct hda_verb alc662_sixstack_ch6_init[] = {
16492 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16493 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16494 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16495 	{ } /* end */
16496 };
16497 
16498 /*
16499  * 6ch mode
16500  */
16501 static struct hda_verb alc662_sixstack_ch8_init[] = {
16502 	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16503 	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16504 	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16505 	{ } /* end */
16506 };
16507 
16508 static struct hda_channel_mode alc662_5stack_modes[2] = {
16509 	{ 2, alc662_sixstack_ch6_init },
16510 	{ 6, alc662_sixstack_ch8_init },
16511 };
16512 
16513 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16514  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16515  */
16516 
16517 static struct snd_kcontrol_new alc662_base_mixer[] = {
16518 	/* output mixer control */
16519 	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16520 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16521 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16522 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16523 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16524 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16525 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16526 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16527 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16528 
16529 	/*Input mixer control */
16530 	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16531 	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16532 	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16533 	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16534 	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16535 	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16536 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16537 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16538 	{ } /* end */
16539 };
16540 
16541 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16542 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16543 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16544 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16545 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16546 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16547 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16548 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16549 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16550 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16551 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16552 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16553 	{ } /* end */
16554 };
16555 
16556 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16557 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16558 	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16559 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16560 	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16561 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16562 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16563 	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16564 	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16565 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16566 	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16567 	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16568 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16569 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16570 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16571 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16572 	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16573 	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16574 	{ } /* end */
16575 };
16576 
16577 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16578 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16579 	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16580 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16581 	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16582 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16583 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16584 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16585 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16586 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16587 	{ } /* end */
16588 };
16589 
16590 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16591 	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16592 	ALC262_HIPPO_MASTER_SWITCH,
16593 
16594 	HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16595 	HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16596 	HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16597 
16598 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16599 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16600 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16601 	{ } /* end */
16602 };
16603 
16604 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16605 	ALC262_HIPPO_MASTER_SWITCH,
16606 	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16607 	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16608 	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16609 	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16610 	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16611 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16612 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16613 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16614 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16615 	{ } /* end */
16616 };
16617 
16618 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16619 	.ops = &snd_hda_bind_vol,
16620 	.values = {
16621 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16622 		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16623 		0
16624 	},
16625 };
16626 
16627 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16628 	.ops = &snd_hda_bind_sw,
16629 	.values = {
16630 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16631 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16632 		0
16633 	},
16634 };
16635 
16636 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16637 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16638 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16639 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16640 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16641 	{ } /* end */
16642 };
16643 
16644 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16645 	.ops = &snd_hda_bind_sw,
16646 	.values = {
16647 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16648 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16649 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16650 		0
16651 	},
16652 };
16653 
16654 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16655 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16656 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16657 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16658 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16659 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16660 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16661 
16662 	{ } /* end */
16663 };
16664 
16665 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16666 	.ops = &snd_hda_bind_sw,
16667 	.values = {
16668 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16669 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16670 		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16671 		0
16672 	},
16673 };
16674 
16675 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16676 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16677 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16678 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16679 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16680 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16681 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16682 	{ } /* end */
16683 };
16684 
16685 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16686 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16687 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16688 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16689 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16690 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16691 	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16692 	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16693 	{ } /* end */
16694 };
16695 
16696 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16697 	.ops = &snd_hda_bind_vol,
16698 	.values = {
16699 		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16700 		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16701 		0
16702 	},
16703 };
16704 
16705 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16706 	.ops = &snd_hda_bind_sw,
16707 	.values = {
16708 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16709 		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16710 		0
16711 	},
16712 };
16713 
16714 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16715 	HDA_BIND_VOL("Master Playback Volume",
16716 				&alc663_asus_two_bind_master_vol),
16717 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16718 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16719 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16720 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16721 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16722 	{ } /* end */
16723 };
16724 
16725 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16726 	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16727 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16728 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16729 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16730 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16731 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16732 	{ } /* end */
16733 };
16734 
16735 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16736 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16737 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16738 	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16739 	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16740 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16741 
16742 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16743 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16744 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16745 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16746 	{ } /* end */
16747 };
16748 
16749 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16750 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16751 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16752 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16753 
16754 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16755 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16756 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16757 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16758 	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16759 	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16760 	{ } /* end */
16761 };
16762 
16763 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16764 	.ops = &snd_hda_bind_sw,
16765 	.values = {
16766 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16767 		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16768 		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16769 		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16770 		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16771 		0
16772 	},
16773 };
16774 
16775 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16776 	.ops = &snd_hda_bind_sw,
16777 	.values = {
16778 		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16779 		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16780 		0
16781 	},
16782 };
16783 
16784 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16785 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16786 	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16787 	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16788 	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16789 	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16790 	HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16791 	HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16792 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16793 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16794 	{ } /* end */
16795 };
16796 
16797 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16798 	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16799 	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16800 	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16801 	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16802 	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16803 	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16804 	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16805 	{ } /* end */
16806 };
16807 
16808 
16809 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16810 	{
16811 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16812 		.name = "Channel Mode",
16813 		.info = alc_ch_mode_info,
16814 		.get = alc_ch_mode_get,
16815 		.put = alc_ch_mode_put,
16816 	},
16817 	{ } /* end */
16818 };
16819 
16820 static struct hda_verb alc662_init_verbs[] = {
16821 	/* ADC: mute amp left and right */
16822 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16823 	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16824 
16825 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16826 	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16827 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16828 	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16829 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16830 	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16831 
16832 	/* Front Pin: output 0 (0x0c) */
16833 	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16834 	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16835 
16836 	/* Rear Pin: output 1 (0x0d) */
16837 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16838 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16839 
16840 	/* CLFE Pin: output 2 (0x0e) */
16841 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16842 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16843 
16844 	/* Mic (rear) pin: input vref at 80% */
16845 	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16846 	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16847 	/* Front Mic pin: input vref at 80% */
16848 	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16849 	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16850 	/* Line In pin: input */
16851 	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16852 	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16853 	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16854 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16855 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16856 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16857 	/* CD pin widget for input */
16858 	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16859 
16860 	/* FIXME: use matrix-type input source selection */
16861 	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16862 	/* Input mixer */
16863 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16864 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16865 
16866 	/* always trun on EAPD */
16867 	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16868 	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16869 
16870 	{ }
16871 };
16872 
16873 static struct hda_verb alc663_init_verbs[] = {
16874 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16875 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16876 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16877 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16878 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16879 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16880 	{ }
16881 };
16882 
16883 static struct hda_verb alc272_init_verbs[] = {
16884 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16885 	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16886 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16887 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16888 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16889 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16890 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16891 	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16892 	{ }
16893 };
16894 
16895 static struct hda_verb alc662_sue_init_verbs[] = {
16896 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16897 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16898 	{}
16899 };
16900 
16901 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16902 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16903 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16904 	{}
16905 };
16906 
16907 /* Set Unsolicited Event*/
16908 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16909 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16910 	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16911 	{}
16912 };
16913 
16914 static struct hda_verb alc663_m51va_init_verbs[] = {
16915 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16916 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16917 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16918 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16919 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16920 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16921 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16922 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16923 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16924 	{}
16925 };
16926 
16927 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16928 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16929 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16930 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16931 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16932 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16933 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16934 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16935 	{}
16936 };
16937 
16938 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16939 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16940 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16941 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16942 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
16943 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16944 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16945 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16946 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16947 	{}
16948 };
16949 
16950 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16951 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16952 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16953 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16954 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16955 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16956 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16957 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16958 	{}
16959 };
16960 
16961 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16962 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16963 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16964 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16965 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
16966 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16967 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16968 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
16969 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16970 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16971 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16972 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16973 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16974 	{}
16975 };
16976 
16977 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16978 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16979 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16980 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16981 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16982 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16983 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16984 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
16985 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16986 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16987 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16988 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16989 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16990 	{}
16991 };
16992 
16993 static struct hda_verb alc663_g71v_init_verbs[] = {
16994 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16995 	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16996 	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16997 
16998 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16999 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17000 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17001 
17002 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17003 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17004 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17005 	{}
17006 };
17007 
17008 static struct hda_verb alc663_g50v_init_verbs[] = {
17009 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17010 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17011 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17012 
17013 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17014 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17015 	{}
17016 };
17017 
17018 static struct hda_verb alc662_ecs_init_verbs[] = {
17019 	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17020 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17021 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17022 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17023 	{}
17024 };
17025 
17026 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17027 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17028 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17029 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17030 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17031 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17032 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17033 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17034 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17035 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17036 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17037 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17038 	{}
17039 };
17040 
17041 static struct hda_verb alc272_dell_init_verbs[] = {
17042 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17043 	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17044 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17045 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17046 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17047 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17048 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17049 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17050 	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17051 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17052 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17053 	{}
17054 };
17055 
17056 static struct hda_verb alc663_mode7_init_verbs[] = {
17057 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17058 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17059 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17060 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17061 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17062 	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17063 	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
17064 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17065 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17066 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17067 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17068 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17069 	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17070 	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17071 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17072 	{}
17073 };
17074 
17075 static struct hda_verb alc663_mode8_init_verbs[] = {
17076 	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17077 	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17078 	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17079 	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
17080 	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17081 	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17082 	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17083 	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17084 	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17085 	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17086 	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17087 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17088 	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17089 	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17090 	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17091 	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17092 	{}
17093 };
17094 
17095 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17096 	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17097 	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17098 	{ } /* end */
17099 };
17100 
17101 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17102 	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17103 	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17104 	{ } /* end */
17105 };
17106 
17107 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17108 {
17109 	unsigned int present;
17110 	unsigned char bits;
17111 
17112 	present = snd_hda_jack_detect(codec, 0x14);
17113 	bits = present ? HDA_AMP_MUTE : 0;
17114 
17115 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17116 				 HDA_AMP_MUTE, bits);
17117 }
17118 
17119 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17120 {
17121 	unsigned int present;
17122 	unsigned char bits;
17123 
17124  	present = snd_hda_jack_detect(codec, 0x1b);
17125 	bits = present ? HDA_AMP_MUTE : 0;
17126 
17127 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17128 				 HDA_AMP_MUTE, bits);
17129 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17130 				 HDA_AMP_MUTE, bits);
17131 }
17132 
17133 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17134 					   unsigned int res)
17135 {
17136 	if ((res >> 26) == ALC880_HP_EVENT)
17137 		alc662_lenovo_101e_all_automute(codec);
17138 	if ((res >> 26) == ALC880_FRONT_EVENT)
17139 		alc662_lenovo_101e_ispeaker_automute(codec);
17140 }
17141 
17142 /* unsolicited event for HP jack sensing */
17143 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17144 				     unsigned int res)
17145 {
17146 	if ((res >> 26) == ALC880_MIC_EVENT)
17147 		alc_mic_automute(codec);
17148 	else
17149 		alc262_hippo_unsol_event(codec, res);
17150 }
17151 
17152 static void alc662_eeepc_setup(struct hda_codec *codec)
17153 {
17154 	struct alc_spec *spec = codec->spec;
17155 
17156 	alc262_hippo1_setup(codec);
17157 	spec->ext_mic.pin = 0x18;
17158 	spec->ext_mic.mux_idx = 0;
17159 	spec->int_mic.pin = 0x19;
17160 	spec->int_mic.mux_idx = 1;
17161 	spec->auto_mic = 1;
17162 }
17163 
17164 static void alc662_eeepc_inithook(struct hda_codec *codec)
17165 {
17166 	alc262_hippo_automute(codec);
17167 	alc_mic_automute(codec);
17168 }
17169 
17170 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
17171 {
17172 	struct alc_spec *spec = codec->spec;
17173 
17174 	spec->autocfg.hp_pins[0] = 0x14;
17175 	spec->autocfg.speaker_pins[0] = 0x1b;
17176 }
17177 
17178 #define alc662_eeepc_ep20_inithook	alc262_hippo_master_update
17179 
17180 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
17181 {
17182 	unsigned int present;
17183 	unsigned char bits;
17184 
17185 	present = snd_hda_jack_detect(codec, 0x21);
17186 	bits = present ? HDA_AMP_MUTE : 0;
17187 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17188 				 HDA_AMP_MUTE, bits);
17189 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17190 				 HDA_AMP_MUTE, bits);
17191 }
17192 
17193 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
17194 {
17195 	unsigned int present;
17196 	unsigned char bits;
17197 
17198 	present = snd_hda_jack_detect(codec, 0x21);
17199 	bits = present ? HDA_AMP_MUTE : 0;
17200 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17201 				 HDA_AMP_MUTE, bits);
17202 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17203 				 HDA_AMP_MUTE, bits);
17204 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17205 				 HDA_AMP_MUTE, bits);
17206 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17207 				 HDA_AMP_MUTE, bits);
17208 }
17209 
17210 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
17211 {
17212 	unsigned int present;
17213 	unsigned char bits;
17214 
17215 	present = snd_hda_jack_detect(codec, 0x15);
17216 	bits = present ? HDA_AMP_MUTE : 0;
17217 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17218 				 HDA_AMP_MUTE, bits);
17219 	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17220 				 HDA_AMP_MUTE, bits);
17221 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17222 				 HDA_AMP_MUTE, bits);
17223 	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17224 				 HDA_AMP_MUTE, bits);
17225 }
17226 
17227 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
17228 {
17229 	unsigned int present;
17230 	unsigned char bits;
17231 
17232 	present = snd_hda_jack_detect(codec, 0x1b);
17233 	bits = present ? 0 : PIN_OUT;
17234 	snd_hda_codec_write(codec, 0x14, 0,
17235 			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
17236 }
17237 
17238 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
17239 {
17240 	unsigned int present1, present2;
17241 
17242 	present1 = snd_hda_jack_detect(codec, 0x21);
17243 	present2 = snd_hda_jack_detect(codec, 0x15);
17244 
17245 	if (present1 || present2) {
17246 		snd_hda_codec_write_cache(codec, 0x14, 0,
17247 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17248 	} else {
17249 		snd_hda_codec_write_cache(codec, 0x14, 0,
17250 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17251 	}
17252 }
17253 
17254 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
17255 {
17256 	unsigned int present1, present2;
17257 
17258 	present1 = snd_hda_jack_detect(codec, 0x1b);
17259 	present2 = snd_hda_jack_detect(codec, 0x15);
17260 
17261 	if (present1 || present2) {
17262 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17263 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
17264 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17265 					 HDA_AMP_MUTE, HDA_AMP_MUTE);
17266 	} else {
17267 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17268 					 HDA_AMP_MUTE, 0);
17269 		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17270 					 HDA_AMP_MUTE, 0);
17271 	}
17272 }
17273 
17274 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
17275 {
17276 	unsigned int present1, present2;
17277 
17278 	present1 = snd_hda_codec_read(codec, 0x1b, 0,
17279 			AC_VERB_GET_PIN_SENSE, 0)
17280 			& AC_PINSENSE_PRESENCE;
17281 	present2 = snd_hda_codec_read(codec, 0x21, 0,
17282 			AC_VERB_GET_PIN_SENSE, 0)
17283 			& AC_PINSENSE_PRESENCE;
17284 
17285 	if (present1 || present2) {
17286 		snd_hda_codec_write_cache(codec, 0x14, 0,
17287 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17288 		snd_hda_codec_write_cache(codec, 0x17, 0,
17289 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17290 	} else {
17291 		snd_hda_codec_write_cache(codec, 0x14, 0,
17292 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17293 		snd_hda_codec_write_cache(codec, 0x17, 0,
17294 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17295 	}
17296 }
17297 
17298 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
17299 {
17300 	unsigned int present1, present2;
17301 
17302 	present1 = snd_hda_codec_read(codec, 0x21, 0,
17303 			AC_VERB_GET_PIN_SENSE, 0)
17304 			& AC_PINSENSE_PRESENCE;
17305 	present2 = snd_hda_codec_read(codec, 0x15, 0,
17306 			AC_VERB_GET_PIN_SENSE, 0)
17307 			& AC_PINSENSE_PRESENCE;
17308 
17309 	if (present1 || present2) {
17310 		snd_hda_codec_write_cache(codec, 0x14, 0,
17311 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17312 		snd_hda_codec_write_cache(codec, 0x17, 0,
17313 			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17314 	} else {
17315 		snd_hda_codec_write_cache(codec, 0x14, 0,
17316 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17317 		snd_hda_codec_write_cache(codec, 0x17, 0,
17318 			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17319 	}
17320 }
17321 
17322 static void alc663_m51va_unsol_event(struct hda_codec *codec,
17323 					   unsigned int res)
17324 {
17325 	switch (res >> 26) {
17326 	case ALC880_HP_EVENT:
17327 		alc663_m51va_speaker_automute(codec);
17328 		break;
17329 	case ALC880_MIC_EVENT:
17330 		alc_mic_automute(codec);
17331 		break;
17332 	}
17333 }
17334 
17335 static void alc663_m51va_setup(struct hda_codec *codec)
17336 {
17337 	struct alc_spec *spec = codec->spec;
17338 	spec->ext_mic.pin = 0x18;
17339 	spec->ext_mic.mux_idx = 0;
17340 	spec->int_mic.pin = 0x12;
17341 	spec->int_mic.mux_idx = 9;
17342 	spec->auto_mic = 1;
17343 }
17344 
17345 static void alc663_m51va_inithook(struct hda_codec *codec)
17346 {
17347 	alc663_m51va_speaker_automute(codec);
17348 	alc_mic_automute(codec);
17349 }
17350 
17351 /* ***************** Mode1 ******************************/
17352 #define alc663_mode1_unsol_event	alc663_m51va_unsol_event
17353 
17354 static void alc663_mode1_setup(struct hda_codec *codec)
17355 {
17356 	struct alc_spec *spec = codec->spec;
17357 	spec->ext_mic.pin = 0x18;
17358 	spec->ext_mic.mux_idx = 0;
17359 	spec->int_mic.pin = 0x19;
17360 	spec->int_mic.mux_idx = 1;
17361 	spec->auto_mic = 1;
17362 }
17363 
17364 #define alc663_mode1_inithook		alc663_m51va_inithook
17365 
17366 /* ***************** Mode2 ******************************/
17367 static void alc662_mode2_unsol_event(struct hda_codec *codec,
17368 					   unsigned int res)
17369 {
17370 	switch (res >> 26) {
17371 	case ALC880_HP_EVENT:
17372 		alc662_f5z_speaker_automute(codec);
17373 		break;
17374 	case ALC880_MIC_EVENT:
17375 		alc_mic_automute(codec);
17376 		break;
17377 	}
17378 }
17379 
17380 #define alc662_mode2_setup	alc663_mode1_setup
17381 
17382 static void alc662_mode2_inithook(struct hda_codec *codec)
17383 {
17384 	alc662_f5z_speaker_automute(codec);
17385 	alc_mic_automute(codec);
17386 }
17387 /* ***************** Mode3 ******************************/
17388 static void alc663_mode3_unsol_event(struct hda_codec *codec,
17389 					   unsigned int res)
17390 {
17391 	switch (res >> 26) {
17392 	case ALC880_HP_EVENT:
17393 		alc663_two_hp_m1_speaker_automute(codec);
17394 		break;
17395 	case ALC880_MIC_EVENT:
17396 		alc_mic_automute(codec);
17397 		break;
17398 	}
17399 }
17400 
17401 #define alc663_mode3_setup	alc663_mode1_setup
17402 
17403 static void alc663_mode3_inithook(struct hda_codec *codec)
17404 {
17405 	alc663_two_hp_m1_speaker_automute(codec);
17406 	alc_mic_automute(codec);
17407 }
17408 /* ***************** Mode4 ******************************/
17409 static void alc663_mode4_unsol_event(struct hda_codec *codec,
17410 					   unsigned int res)
17411 {
17412 	switch (res >> 26) {
17413 	case ALC880_HP_EVENT:
17414 		alc663_21jd_two_speaker_automute(codec);
17415 		break;
17416 	case ALC880_MIC_EVENT:
17417 		alc_mic_automute(codec);
17418 		break;
17419 	}
17420 }
17421 
17422 #define alc663_mode4_setup	alc663_mode1_setup
17423 
17424 static void alc663_mode4_inithook(struct hda_codec *codec)
17425 {
17426 	alc663_21jd_two_speaker_automute(codec);
17427 	alc_mic_automute(codec);
17428 }
17429 /* ***************** Mode5 ******************************/
17430 static void alc663_mode5_unsol_event(struct hda_codec *codec,
17431 					   unsigned int res)
17432 {
17433 	switch (res >> 26) {
17434 	case ALC880_HP_EVENT:
17435 		alc663_15jd_two_speaker_automute(codec);
17436 		break;
17437 	case ALC880_MIC_EVENT:
17438 		alc_mic_automute(codec);
17439 		break;
17440 	}
17441 }
17442 
17443 #define alc663_mode5_setup	alc663_mode1_setup
17444 
17445 static void alc663_mode5_inithook(struct hda_codec *codec)
17446 {
17447 	alc663_15jd_two_speaker_automute(codec);
17448 	alc_mic_automute(codec);
17449 }
17450 /* ***************** Mode6 ******************************/
17451 static void alc663_mode6_unsol_event(struct hda_codec *codec,
17452 					   unsigned int res)
17453 {
17454 	switch (res >> 26) {
17455 	case ALC880_HP_EVENT:
17456 		alc663_two_hp_m2_speaker_automute(codec);
17457 		break;
17458 	case ALC880_MIC_EVENT:
17459 		alc_mic_automute(codec);
17460 		break;
17461 	}
17462 }
17463 
17464 #define alc663_mode6_setup	alc663_mode1_setup
17465 
17466 static void alc663_mode6_inithook(struct hda_codec *codec)
17467 {
17468 	alc663_two_hp_m2_speaker_automute(codec);
17469 	alc_mic_automute(codec);
17470 }
17471 
17472 /* ***************** Mode7 ******************************/
17473 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17474 					   unsigned int res)
17475 {
17476 	switch (res >> 26) {
17477 	case ALC880_HP_EVENT:
17478 		alc663_two_hp_m7_speaker_automute(codec);
17479 		break;
17480 	case ALC880_MIC_EVENT:
17481 		alc_mic_automute(codec);
17482 		break;
17483 	}
17484 }
17485 
17486 #define alc663_mode7_setup	alc663_mode1_setup
17487 
17488 static void alc663_mode7_inithook(struct hda_codec *codec)
17489 {
17490 	alc663_two_hp_m7_speaker_automute(codec);
17491 	alc_mic_automute(codec);
17492 }
17493 
17494 /* ***************** Mode8 ******************************/
17495 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17496 					   unsigned int res)
17497 {
17498 	switch (res >> 26) {
17499 	case ALC880_HP_EVENT:
17500 		alc663_two_hp_m8_speaker_automute(codec);
17501 		break;
17502 	case ALC880_MIC_EVENT:
17503 		alc_mic_automute(codec);
17504 		break;
17505 	}
17506 }
17507 
17508 #define alc663_mode8_setup	alc663_m51va_setup
17509 
17510 static void alc663_mode8_inithook(struct hda_codec *codec)
17511 {
17512 	alc663_two_hp_m8_speaker_automute(codec);
17513 	alc_mic_automute(codec);
17514 }
17515 
17516 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17517 {
17518 	unsigned int present;
17519 	unsigned char bits;
17520 
17521 	present = snd_hda_jack_detect(codec, 0x21);
17522 	bits = present ? HDA_AMP_MUTE : 0;
17523 	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17524 				 HDA_AMP_MUTE, bits);
17525 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17526 				 HDA_AMP_MUTE, bits);
17527 }
17528 
17529 static void alc663_g71v_front_automute(struct hda_codec *codec)
17530 {
17531 	unsigned int present;
17532 	unsigned char bits;
17533 
17534 	present = snd_hda_jack_detect(codec, 0x15);
17535 	bits = present ? HDA_AMP_MUTE : 0;
17536 	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17537 				 HDA_AMP_MUTE, bits);
17538 }
17539 
17540 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17541 					   unsigned int res)
17542 {
17543 	switch (res >> 26) {
17544 	case ALC880_HP_EVENT:
17545 		alc663_g71v_hp_automute(codec);
17546 		break;
17547 	case ALC880_FRONT_EVENT:
17548 		alc663_g71v_front_automute(codec);
17549 		break;
17550 	case ALC880_MIC_EVENT:
17551 		alc_mic_automute(codec);
17552 		break;
17553 	}
17554 }
17555 
17556 #define alc663_g71v_setup	alc663_m51va_setup
17557 
17558 static void alc663_g71v_inithook(struct hda_codec *codec)
17559 {
17560 	alc663_g71v_front_automute(codec);
17561 	alc663_g71v_hp_automute(codec);
17562 	alc_mic_automute(codec);
17563 }
17564 
17565 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17566 					   unsigned int res)
17567 {
17568 	switch (res >> 26) {
17569 	case ALC880_HP_EVENT:
17570 		alc663_m51va_speaker_automute(codec);
17571 		break;
17572 	case ALC880_MIC_EVENT:
17573 		alc_mic_automute(codec);
17574 		break;
17575 	}
17576 }
17577 
17578 #define alc663_g50v_setup	alc663_m51va_setup
17579 
17580 static void alc663_g50v_inithook(struct hda_codec *codec)
17581 {
17582 	alc663_m51va_speaker_automute(codec);
17583 	alc_mic_automute(codec);
17584 }
17585 
17586 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17587 	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17588 	ALC262_HIPPO_MASTER_SWITCH,
17589 
17590 	HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17591 	HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17592 	HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17593 
17594 	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17595 	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17596 	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17597 	{ } /* end */
17598 };
17599 
17600 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17601 	/* Master Playback automatically created from Speaker and Headphone */
17602 	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17603 	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17604 	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17605 	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17606 
17607 	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17608 	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17609 	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17610 
17611 	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17612 	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17613 	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17614 	{ } /* end */
17615 };
17616 
17617 #ifdef CONFIG_SND_HDA_POWER_SAVE
17618 #define alc662_loopbacks	alc880_loopbacks
17619 #endif
17620 
17621 
17622 /* pcm configuration: identical with ALC880 */
17623 #define alc662_pcm_analog_playback	alc880_pcm_analog_playback
17624 #define alc662_pcm_analog_capture	alc880_pcm_analog_capture
17625 #define alc662_pcm_digital_playback	alc880_pcm_digital_playback
17626 #define alc662_pcm_digital_capture	alc880_pcm_digital_capture
17627 
17628 /*
17629  * configuration and preset
17630  */
17631 static const char *alc662_models[ALC662_MODEL_LAST] = {
17632 	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
17633 	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
17634 	[ALC662_3ST_6ch]	= "3stack-6ch",
17635 	[ALC662_5ST_DIG]	= "6stack-dig",
17636 	[ALC662_LENOVO_101E]	= "lenovo-101e",
17637 	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17638 	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17639 	[ALC662_ECS] = "ecs",
17640 	[ALC663_ASUS_M51VA] = "m51va",
17641 	[ALC663_ASUS_G71V] = "g71v",
17642 	[ALC663_ASUS_H13] = "h13",
17643 	[ALC663_ASUS_G50V] = "g50v",
17644 	[ALC663_ASUS_MODE1] = "asus-mode1",
17645 	[ALC662_ASUS_MODE2] = "asus-mode2",
17646 	[ALC663_ASUS_MODE3] = "asus-mode3",
17647 	[ALC663_ASUS_MODE4] = "asus-mode4",
17648 	[ALC663_ASUS_MODE5] = "asus-mode5",
17649 	[ALC663_ASUS_MODE6] = "asus-mode6",
17650 	[ALC663_ASUS_MODE7] = "asus-mode7",
17651 	[ALC663_ASUS_MODE8] = "asus-mode8",
17652 	[ALC272_DELL]		= "dell",
17653 	[ALC272_DELL_ZM1]	= "dell-zm1",
17654 	[ALC272_SAMSUNG_NC10]	= "samsung-nc10",
17655 	[ALC662_AUTO]		= "auto",
17656 };
17657 
17658 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17659 	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17660 	SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17661 	SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17662 	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17663 	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17664 	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
17665 	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17666 	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17667 	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17668 	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17669 	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17670 	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17671 	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17672 	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17673 	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17674 	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17675 	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17676 	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17677 	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17678 	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17679 	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17680 	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17681 	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17682 	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17683 	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17684 	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17685 	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17686 	SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17687 	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17688 	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17689 	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17690 	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17691 	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17692 	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17693 	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17694 	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17695 	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17696 	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17697 	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17698 	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17699 	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17700 	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
17701 	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17702 	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17703 	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17704 	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17705 	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17706 	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17707 	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17708 	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17709 	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17710 	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17711 	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17712 	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17713 	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17714 	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17715 	SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17716 	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17717 	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17718 	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17719 	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17720 	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17721 	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17722 	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17723 		      ALC662_3ST_6ch_DIG),
17724 	SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
17725 	SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17726 	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17727 		      ALC662_3ST_6ch_DIG),
17728 	SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
17729 	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17730 	SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17731 	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17732 	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17733 					ALC662_3ST_6ch_DIG),
17734 	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17735 			   ALC663_ASUS_H13),
17736 	SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17737 	{}
17738 };
17739 
17740 static struct alc_config_preset alc662_presets[] = {
17741 	[ALC662_3ST_2ch_DIG] = {
17742 		.mixers = { alc662_3ST_2ch_mixer },
17743 		.init_verbs = { alc662_init_verbs },
17744 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17745 		.dac_nids = alc662_dac_nids,
17746 		.dig_out_nid = ALC662_DIGOUT_NID,
17747 		.dig_in_nid = ALC662_DIGIN_NID,
17748 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17749 		.channel_mode = alc662_3ST_2ch_modes,
17750 		.input_mux = &alc662_capture_source,
17751 	},
17752 	[ALC662_3ST_6ch_DIG] = {
17753 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17754 		.init_verbs = { alc662_init_verbs },
17755 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17756 		.dac_nids = alc662_dac_nids,
17757 		.dig_out_nid = ALC662_DIGOUT_NID,
17758 		.dig_in_nid = ALC662_DIGIN_NID,
17759 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17760 		.channel_mode = alc662_3ST_6ch_modes,
17761 		.need_dac_fix = 1,
17762 		.input_mux = &alc662_capture_source,
17763 	},
17764 	[ALC662_3ST_6ch] = {
17765 		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17766 		.init_verbs = { alc662_init_verbs },
17767 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17768 		.dac_nids = alc662_dac_nids,
17769 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17770 		.channel_mode = alc662_3ST_6ch_modes,
17771 		.need_dac_fix = 1,
17772 		.input_mux = &alc662_capture_source,
17773 	},
17774 	[ALC662_5ST_DIG] = {
17775 		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
17776 		.init_verbs = { alc662_init_verbs },
17777 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17778 		.dac_nids = alc662_dac_nids,
17779 		.dig_out_nid = ALC662_DIGOUT_NID,
17780 		.dig_in_nid = ALC662_DIGIN_NID,
17781 		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17782 		.channel_mode = alc662_5stack_modes,
17783 		.input_mux = &alc662_capture_source,
17784 	},
17785 	[ALC662_LENOVO_101E] = {
17786 		.mixers = { alc662_lenovo_101e_mixer },
17787 		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17788 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17789 		.dac_nids = alc662_dac_nids,
17790 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17791 		.channel_mode = alc662_3ST_2ch_modes,
17792 		.input_mux = &alc662_lenovo_101e_capture_source,
17793 		.unsol_event = alc662_lenovo_101e_unsol_event,
17794 		.init_hook = alc662_lenovo_101e_all_automute,
17795 	},
17796 	[ALC662_ASUS_EEEPC_P701] = {
17797 		.mixers = { alc662_eeepc_p701_mixer },
17798 		.init_verbs = { alc662_init_verbs,
17799 				alc662_eeepc_sue_init_verbs },
17800 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17801 		.dac_nids = alc662_dac_nids,
17802 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17803 		.channel_mode = alc662_3ST_2ch_modes,
17804 		.unsol_event = alc662_eeepc_unsol_event,
17805 		.setup = alc662_eeepc_setup,
17806 		.init_hook = alc662_eeepc_inithook,
17807 	},
17808 	[ALC662_ASUS_EEEPC_EP20] = {
17809 		.mixers = { alc662_eeepc_ep20_mixer,
17810 			    alc662_chmode_mixer },
17811 		.init_verbs = { alc662_init_verbs,
17812 				alc662_eeepc_ep20_sue_init_verbs },
17813 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17814 		.dac_nids = alc662_dac_nids,
17815 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17816 		.channel_mode = alc662_3ST_6ch_modes,
17817 		.input_mux = &alc662_lenovo_101e_capture_source,
17818 		.unsol_event = alc662_eeepc_unsol_event,
17819 		.setup = alc662_eeepc_ep20_setup,
17820 		.init_hook = alc662_eeepc_ep20_inithook,
17821 	},
17822 	[ALC662_ECS] = {
17823 		.mixers = { alc662_ecs_mixer },
17824 		.init_verbs = { alc662_init_verbs,
17825 				alc662_ecs_init_verbs },
17826 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17827 		.dac_nids = alc662_dac_nids,
17828 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17829 		.channel_mode = alc662_3ST_2ch_modes,
17830 		.unsol_event = alc662_eeepc_unsol_event,
17831 		.setup = alc662_eeepc_setup,
17832 		.init_hook = alc662_eeepc_inithook,
17833 	},
17834 	[ALC663_ASUS_M51VA] = {
17835 		.mixers = { alc663_m51va_mixer },
17836 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17837 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17838 		.dac_nids = alc662_dac_nids,
17839 		.dig_out_nid = ALC662_DIGOUT_NID,
17840 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17841 		.channel_mode = alc662_3ST_2ch_modes,
17842 		.unsol_event = alc663_m51va_unsol_event,
17843 		.setup = alc663_m51va_setup,
17844 		.init_hook = alc663_m51va_inithook,
17845 	},
17846 	[ALC663_ASUS_G71V] = {
17847 		.mixers = { alc663_g71v_mixer },
17848 		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17849 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17850 		.dac_nids = alc662_dac_nids,
17851 		.dig_out_nid = ALC662_DIGOUT_NID,
17852 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17853 		.channel_mode = alc662_3ST_2ch_modes,
17854 		.unsol_event = alc663_g71v_unsol_event,
17855 		.setup = alc663_g71v_setup,
17856 		.init_hook = alc663_g71v_inithook,
17857 	},
17858 	[ALC663_ASUS_H13] = {
17859 		.mixers = { alc663_m51va_mixer },
17860 		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17861 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17862 		.dac_nids = alc662_dac_nids,
17863 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17864 		.channel_mode = alc662_3ST_2ch_modes,
17865 		.unsol_event = alc663_m51va_unsol_event,
17866 		.init_hook = alc663_m51va_inithook,
17867 	},
17868 	[ALC663_ASUS_G50V] = {
17869 		.mixers = { alc663_g50v_mixer },
17870 		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17871 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17872 		.dac_nids = alc662_dac_nids,
17873 		.dig_out_nid = ALC662_DIGOUT_NID,
17874 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17875 		.channel_mode = alc662_3ST_6ch_modes,
17876 		.input_mux = &alc663_capture_source,
17877 		.unsol_event = alc663_g50v_unsol_event,
17878 		.setup = alc663_g50v_setup,
17879 		.init_hook = alc663_g50v_inithook,
17880 	},
17881 	[ALC663_ASUS_MODE1] = {
17882 		.mixers = { alc663_m51va_mixer },
17883 		.cap_mixer = alc662_auto_capture_mixer,
17884 		.init_verbs = { alc662_init_verbs,
17885 				alc663_21jd_amic_init_verbs },
17886 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17887 		.hp_nid = 0x03,
17888 		.dac_nids = alc662_dac_nids,
17889 		.dig_out_nid = ALC662_DIGOUT_NID,
17890 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17891 		.channel_mode = alc662_3ST_2ch_modes,
17892 		.unsol_event = alc663_mode1_unsol_event,
17893 		.setup = alc663_mode1_setup,
17894 		.init_hook = alc663_mode1_inithook,
17895 	},
17896 	[ALC662_ASUS_MODE2] = {
17897 		.mixers = { alc662_1bjd_mixer },
17898 		.cap_mixer = alc662_auto_capture_mixer,
17899 		.init_verbs = { alc662_init_verbs,
17900 				alc662_1bjd_amic_init_verbs },
17901 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17902 		.dac_nids = alc662_dac_nids,
17903 		.dig_out_nid = ALC662_DIGOUT_NID,
17904 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17905 		.channel_mode = alc662_3ST_2ch_modes,
17906 		.unsol_event = alc662_mode2_unsol_event,
17907 		.setup = alc662_mode2_setup,
17908 		.init_hook = alc662_mode2_inithook,
17909 	},
17910 	[ALC663_ASUS_MODE3] = {
17911 		.mixers = { alc663_two_hp_m1_mixer },
17912 		.cap_mixer = alc662_auto_capture_mixer,
17913 		.init_verbs = { alc662_init_verbs,
17914 				alc663_two_hp_amic_m1_init_verbs },
17915 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17916 		.hp_nid = 0x03,
17917 		.dac_nids = alc662_dac_nids,
17918 		.dig_out_nid = ALC662_DIGOUT_NID,
17919 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17920 		.channel_mode = alc662_3ST_2ch_modes,
17921 		.unsol_event = alc663_mode3_unsol_event,
17922 		.setup = alc663_mode3_setup,
17923 		.init_hook = alc663_mode3_inithook,
17924 	},
17925 	[ALC663_ASUS_MODE4] = {
17926 		.mixers = { alc663_asus_21jd_clfe_mixer },
17927 		.cap_mixer = alc662_auto_capture_mixer,
17928 		.init_verbs = { alc662_init_verbs,
17929 				alc663_21jd_amic_init_verbs},
17930 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17931 		.hp_nid = 0x03,
17932 		.dac_nids = alc662_dac_nids,
17933 		.dig_out_nid = ALC662_DIGOUT_NID,
17934 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17935 		.channel_mode = alc662_3ST_2ch_modes,
17936 		.unsol_event = alc663_mode4_unsol_event,
17937 		.setup = alc663_mode4_setup,
17938 		.init_hook = alc663_mode4_inithook,
17939 	},
17940 	[ALC663_ASUS_MODE5] = {
17941 		.mixers = { alc663_asus_15jd_clfe_mixer },
17942 		.cap_mixer = alc662_auto_capture_mixer,
17943 		.init_verbs = { alc662_init_verbs,
17944 				alc663_15jd_amic_init_verbs },
17945 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17946 		.hp_nid = 0x03,
17947 		.dac_nids = alc662_dac_nids,
17948 		.dig_out_nid = ALC662_DIGOUT_NID,
17949 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17950 		.channel_mode = alc662_3ST_2ch_modes,
17951 		.unsol_event = alc663_mode5_unsol_event,
17952 		.setup = alc663_mode5_setup,
17953 		.init_hook = alc663_mode5_inithook,
17954 	},
17955 	[ALC663_ASUS_MODE6] = {
17956 		.mixers = { alc663_two_hp_m2_mixer },
17957 		.cap_mixer = alc662_auto_capture_mixer,
17958 		.init_verbs = { alc662_init_verbs,
17959 				alc663_two_hp_amic_m2_init_verbs },
17960 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17961 		.hp_nid = 0x03,
17962 		.dac_nids = alc662_dac_nids,
17963 		.dig_out_nid = ALC662_DIGOUT_NID,
17964 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17965 		.channel_mode = alc662_3ST_2ch_modes,
17966 		.unsol_event = alc663_mode6_unsol_event,
17967 		.setup = alc663_mode6_setup,
17968 		.init_hook = alc663_mode6_inithook,
17969 	},
17970 	[ALC663_ASUS_MODE7] = {
17971 		.mixers = { alc663_mode7_mixer },
17972 		.cap_mixer = alc662_auto_capture_mixer,
17973 		.init_verbs = { alc662_init_verbs,
17974 				alc663_mode7_init_verbs },
17975 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17976 		.hp_nid = 0x03,
17977 		.dac_nids = alc662_dac_nids,
17978 		.dig_out_nid = ALC662_DIGOUT_NID,
17979 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17980 		.channel_mode = alc662_3ST_2ch_modes,
17981 		.unsol_event = alc663_mode7_unsol_event,
17982 		.setup = alc663_mode7_setup,
17983 		.init_hook = alc663_mode7_inithook,
17984 	},
17985 	[ALC663_ASUS_MODE8] = {
17986 		.mixers = { alc663_mode8_mixer },
17987 		.cap_mixer = alc662_auto_capture_mixer,
17988 		.init_verbs = { alc662_init_verbs,
17989 				alc663_mode8_init_verbs },
17990 		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
17991 		.hp_nid = 0x03,
17992 		.dac_nids = alc662_dac_nids,
17993 		.dig_out_nid = ALC662_DIGOUT_NID,
17994 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17995 		.channel_mode = alc662_3ST_2ch_modes,
17996 		.unsol_event = alc663_mode8_unsol_event,
17997 		.setup = alc663_mode8_setup,
17998 		.init_hook = alc663_mode8_inithook,
17999 	},
18000 	[ALC272_DELL] = {
18001 		.mixers = { alc663_m51va_mixer },
18002 		.cap_mixer = alc272_auto_capture_mixer,
18003 		.init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18004 		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18005 		.dac_nids = alc662_dac_nids,
18006 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18007 		.adc_nids = alc272_adc_nids,
18008 		.num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18009 		.capsrc_nids = alc272_capsrc_nids,
18010 		.channel_mode = alc662_3ST_2ch_modes,
18011 		.unsol_event = alc663_m51va_unsol_event,
18012 		.setup = alc663_m51va_setup,
18013 		.init_hook = alc663_m51va_inithook,
18014 	},
18015 	[ALC272_DELL_ZM1] = {
18016 		.mixers = { alc663_m51va_mixer },
18017 		.cap_mixer = alc662_auto_capture_mixer,
18018 		.init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18019 		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18020 		.dac_nids = alc662_dac_nids,
18021 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18022 		.adc_nids = alc662_adc_nids,
18023 		.num_adc_nids = 1,
18024 		.capsrc_nids = alc662_capsrc_nids,
18025 		.channel_mode = alc662_3ST_2ch_modes,
18026 		.unsol_event = alc663_m51va_unsol_event,
18027 		.setup = alc663_m51va_setup,
18028 		.init_hook = alc663_m51va_inithook,
18029 	},
18030 	[ALC272_SAMSUNG_NC10] = {
18031 		.mixers = { alc272_nc10_mixer },
18032 		.init_verbs = { alc662_init_verbs,
18033 				alc663_21jd_amic_init_verbs },
18034 		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18035 		.dac_nids = alc272_dac_nids,
18036 		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18037 		.channel_mode = alc662_3ST_2ch_modes,
18038 		/*.input_mux = &alc272_nc10_capture_source,*/
18039 		.unsol_event = alc663_mode4_unsol_event,
18040 		.setup = alc663_mode4_setup,
18041 		.init_hook = alc663_mode4_inithook,
18042 	},
18043 };
18044 
18045 
18046 /*
18047  * BIOS auto configuration
18048  */
18049 
18050 /* convert from MIX nid to DAC */
18051 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18052 {
18053 	if (nid == 0x0f)
18054 		return 0x02;
18055 	else if (nid >= 0x0c && nid <= 0x0e)
18056 		return nid - 0x0c + 0x02;
18057 	else
18058 		return 0;
18059 }
18060 
18061 /* get MIX nid connected to the given pin targeted to DAC */
18062 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18063 				   hda_nid_t dac)
18064 {
18065 	hda_nid_t mix[4];
18066 	int i, num;
18067 
18068 	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18069 	for (i = 0; i < num; i++) {
18070 		if (alc662_mix_to_dac(mix[i]) == dac)
18071 			return mix[i];
18072 	}
18073 	return 0;
18074 }
18075 
18076 /* look for an empty DAC slot */
18077 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18078 {
18079 	struct alc_spec *spec = codec->spec;
18080 	hda_nid_t srcs[5];
18081 	int i, j, num;
18082 
18083 	num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18084 	if (num < 0)
18085 		return 0;
18086 	for (i = 0; i < num; i++) {
18087 		hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18088 		if (!nid)
18089 			continue;
18090 		for (j = 0; j < spec->multiout.num_dacs; j++)
18091 			if (spec->multiout.dac_nids[j] == nid)
18092 				break;
18093 		if (j >= spec->multiout.num_dacs)
18094 			return nid;
18095 	}
18096 	return 0;
18097 }
18098 
18099 /* fill in the dac_nids table from the parsed pin configuration */
18100 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18101 				     const struct auto_pin_cfg *cfg)
18102 {
18103 	struct alc_spec *spec = codec->spec;
18104 	int i;
18105 	hda_nid_t dac;
18106 
18107 	spec->multiout.dac_nids = spec->private_dac_nids;
18108 	for (i = 0; i < cfg->line_outs; i++) {
18109 		dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18110 		if (!dac)
18111 			continue;
18112 		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18113 	}
18114 	return 0;
18115 }
18116 
18117 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18118 			      hda_nid_t nid, unsigned int chs)
18119 {
18120 	return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18121 			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18122 }
18123 
18124 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18125 			     hda_nid_t nid, unsigned int chs)
18126 {
18127 	return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18128 			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18129 }
18130 
18131 #define alc662_add_stereo_vol(spec, pfx, nid) \
18132 	alc662_add_vol_ctl(spec, pfx, nid, 3)
18133 #define alc662_add_stereo_sw(spec, pfx, nid) \
18134 	alc662_add_sw_ctl(spec, pfx, nid, 3)
18135 
18136 /* add playback controls from the parsed DAC table */
18137 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18138 					     const struct auto_pin_cfg *cfg)
18139 {
18140 	struct alc_spec *spec = codec->spec;
18141 	static const char *chname[4] = {
18142 		"Front", "Surround", NULL /*CLFE*/, "Side"
18143 	};
18144 	hda_nid_t nid, mix;
18145 	int i, err;
18146 
18147 	for (i = 0; i < cfg->line_outs; i++) {
18148 		nid = spec->multiout.dac_nids[i];
18149 		if (!nid)
18150 			continue;
18151 		mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18152 		if (!mix)
18153 			continue;
18154 		if (i == 2) {
18155 			/* Center/LFE */
18156 			err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18157 			if (err < 0)
18158 				return err;
18159 			err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
18160 			if (err < 0)
18161 				return err;
18162 			err = alc662_add_sw_ctl(spec, "Center", mix, 1);
18163 			if (err < 0)
18164 				return err;
18165 			err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
18166 			if (err < 0)
18167 				return err;
18168 		} else {
18169 			const char *pfx;
18170 			if (cfg->line_outs == 1 &&
18171 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
18172 				if (cfg->hp_outs)
18173 					pfx = "Speaker";
18174 				else
18175 					pfx = "PCM";
18176 			} else
18177 				pfx = chname[i];
18178 			err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18179 			if (err < 0)
18180 				return err;
18181 			if (cfg->line_outs == 1 &&
18182 			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
18183 				pfx = "Speaker";
18184 			err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18185 			if (err < 0)
18186 				return err;
18187 		}
18188 	}
18189 	return 0;
18190 }
18191 
18192 /* add playback controls for speaker and HP outputs */
18193 /* return DAC nid if any new DAC is assigned */
18194 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
18195 					const char *pfx)
18196 {
18197 	struct alc_spec *spec = codec->spec;
18198 	hda_nid_t nid, mix;
18199 	int err;
18200 
18201 	if (!pin)
18202 		return 0;
18203 	nid = alc662_look_for_dac(codec, pin);
18204 	if (!nid) {
18205 		/* the corresponding DAC is already occupied */
18206 		if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
18207 			return 0; /* no way */
18208 		/* create a switch only */
18209 		return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18210 				   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
18211 	}
18212 
18213 	mix = alc662_dac_to_mix(codec, pin, nid);
18214 	if (!mix)
18215 		return 0;
18216 	err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18217 	if (err < 0)
18218 		return err;
18219 	err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18220 	if (err < 0)
18221 		return err;
18222 	return nid;
18223 }
18224 
18225 /* create playback/capture controls for input pins */
18226 #define alc662_auto_create_input_ctls \
18227 	alc882_auto_create_input_ctls
18228 
18229 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
18230 					      hda_nid_t nid, int pin_type,
18231 					      hda_nid_t dac)
18232 {
18233 	int i, num;
18234 	hda_nid_t srcs[4];
18235 
18236 	alc_set_pin_output(codec, nid, pin_type);
18237 	/* need the manual connection? */
18238 	num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
18239 	if (num <= 1)
18240 		return;
18241 	for (i = 0; i < num; i++) {
18242 		if (alc662_mix_to_dac(srcs[i]) != dac)
18243 			continue;
18244 		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
18245 		return;
18246 	}
18247 }
18248 
18249 static void alc662_auto_init_multi_out(struct hda_codec *codec)
18250 {
18251 	struct alc_spec *spec = codec->spec;
18252 	int pin_type = get_pin_type(spec->autocfg.line_out_type);
18253 	int i;
18254 
18255 	for (i = 0; i <= HDA_SIDE; i++) {
18256 		hda_nid_t nid = spec->autocfg.line_out_pins[i];
18257 		if (nid)
18258 			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
18259 					spec->multiout.dac_nids[i]);
18260 	}
18261 }
18262 
18263 static void alc662_auto_init_hp_out(struct hda_codec *codec)
18264 {
18265 	struct alc_spec *spec = codec->spec;
18266 	hda_nid_t pin;
18267 
18268 	pin = spec->autocfg.hp_pins[0];
18269 	if (pin)
18270 		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
18271 						  spec->multiout.hp_nid);
18272 	pin = spec->autocfg.speaker_pins[0];
18273 	if (pin)
18274 		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
18275 					spec->multiout.extra_out_nid[0]);
18276 }
18277 
18278 #define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
18279 
18280 static void alc662_auto_init_analog_input(struct hda_codec *codec)
18281 {
18282 	struct alc_spec *spec = codec->spec;
18283 	int i;
18284 
18285 	for (i = 0; i < AUTO_PIN_LAST; i++) {
18286 		hda_nid_t nid = spec->autocfg.input_pins[i];
18287 		if (alc_is_input_pin(codec, nid)) {
18288 			alc_set_input_pin(codec, nid, i);
18289 			if (nid != ALC662_PIN_CD_NID &&
18290 			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
18291 				snd_hda_codec_write(codec, nid, 0,
18292 						    AC_VERB_SET_AMP_GAIN_MUTE,
18293 						    AMP_OUT_MUTE);
18294 		}
18295 	}
18296 }
18297 
18298 #define alc662_auto_init_input_src	alc882_auto_init_input_src
18299 
18300 static int alc662_parse_auto_config(struct hda_codec *codec)
18301 {
18302 	struct alc_spec *spec = codec->spec;
18303 	int err;
18304 	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
18305 
18306 	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
18307 					   alc662_ignore);
18308 	if (err < 0)
18309 		return err;
18310 	if (!spec->autocfg.line_outs)
18311 		return 0; /* can't find valid BIOS pin config */
18312 
18313 	err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
18314 	if (err < 0)
18315 		return err;
18316 	err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
18317 	if (err < 0)
18318 		return err;
18319 	err = alc662_auto_create_extra_out(codec,
18320 					   spec->autocfg.speaker_pins[0],
18321 					   "Speaker");
18322 	if (err < 0)
18323 		return err;
18324 	if (err)
18325 		spec->multiout.extra_out_nid[0] = err;
18326 	err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
18327 					   "Headphone");
18328 	if (err < 0)
18329 		return err;
18330 	if (err)
18331 		spec->multiout.hp_nid = err;
18332 	err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
18333 	if (err < 0)
18334 		return err;
18335 
18336 	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
18337 
18338 	if (spec->autocfg.dig_outs)
18339 		spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
18340 
18341 	if (spec->kctls.list)
18342 		add_mixer(spec, spec->kctls.list);
18343 
18344 	spec->num_mux_defs = 1;
18345 	spec->input_mux = &spec->private_imux[0];
18346 
18347 	add_verb(spec, alc662_init_verbs);
18348 	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18349 	    codec->vendor_id == 0x10ec0665)
18350 		add_verb(spec, alc663_init_verbs);
18351 
18352 	if (codec->vendor_id == 0x10ec0272)
18353 		add_verb(spec, alc272_init_verbs);
18354 
18355 	err = alc_auto_add_mic_boost(codec);
18356 	if (err < 0)
18357 		return err;
18358 
18359 	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18360 	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
18361 	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
18362 	else
18363 	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
18364 
18365 	return 1;
18366 }
18367 
18368 /* additional initialization for auto-configuration model */
18369 static void alc662_auto_init(struct hda_codec *codec)
18370 {
18371 	struct alc_spec *spec = codec->spec;
18372 	alc662_auto_init_multi_out(codec);
18373 	alc662_auto_init_hp_out(codec);
18374 	alc662_auto_init_analog_input(codec);
18375 	alc662_auto_init_input_src(codec);
18376 	if (spec->unsol_event)
18377 		alc_inithook(codec);
18378 }
18379 
18380 static int patch_alc662(struct hda_codec *codec)
18381 {
18382 	struct alc_spec *spec;
18383 	int err, board_config;
18384 
18385 	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
18386 	if (!spec)
18387 		return -ENOMEM;
18388 
18389 	codec->spec = spec;
18390 
18391 	alc_fix_pll_init(codec, 0x20, 0x04, 15);
18392 
18393 	if (alc_read_coef_idx(codec, 0)==0x8020){
18394 		kfree(codec->chip_name);
18395 		codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
18396 		if (!codec->chip_name) {
18397 			alc_free(codec);
18398 			return -ENOMEM;
18399 		}
18400 	}
18401 
18402 	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
18403 						  alc662_models,
18404 			  	                  alc662_cfg_tbl);
18405 	if (board_config < 0) {
18406 		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
18407 		       codec->chip_name);
18408 		board_config = ALC662_AUTO;
18409 	}
18410 
18411 	if (board_config == ALC662_AUTO) {
18412 		/* automatic parse from the BIOS config */
18413 		err = alc662_parse_auto_config(codec);
18414 		if (err < 0) {
18415 			alc_free(codec);
18416 			return err;
18417 		} else if (!err) {
18418 			printk(KERN_INFO
18419 			       "hda_codec: Cannot set up configuration "
18420 			       "from BIOS.  Using base mode...\n");
18421 			board_config = ALC662_3ST_2ch_DIG;
18422 		}
18423 	}
18424 
18425 	err = snd_hda_attach_beep_device(codec, 0x1);
18426 	if (err < 0) {
18427 		alc_free(codec);
18428 		return err;
18429 	}
18430 
18431 	if (board_config != ALC662_AUTO)
18432 		setup_preset(codec, &alc662_presets[board_config]);
18433 
18434 	spec->stream_analog_playback = &alc662_pcm_analog_playback;
18435 	spec->stream_analog_capture = &alc662_pcm_analog_capture;
18436 
18437 	spec->stream_digital_playback = &alc662_pcm_digital_playback;
18438 	spec->stream_digital_capture = &alc662_pcm_digital_capture;
18439 
18440 	if (!spec->adc_nids) {
18441 		spec->adc_nids = alc662_adc_nids;
18442 		spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
18443 	}
18444 	if (!spec->capsrc_nids)
18445 		spec->capsrc_nids = alc662_capsrc_nids;
18446 
18447 	if (!spec->cap_mixer)
18448 		set_capture_mixer(codec);
18449 
18450 	switch (codec->vendor_id) {
18451 	case 0x10ec0662:
18452 		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
18453 		break;
18454 	case 0x10ec0272:
18455 	case 0x10ec0663:
18456 	case 0x10ec0665:
18457 		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
18458 		break;
18459 	case 0x10ec0273:
18460 		set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
18461 		break;
18462 	}
18463 	spec->vmaster_nid = 0x02;
18464 
18465 	codec->patch_ops = alc_patch_ops;
18466 	if (board_config == ALC662_AUTO)
18467 		spec->init_hook = alc662_auto_init;
18468 #ifdef CONFIG_SND_HDA_POWER_SAVE
18469 	if (!spec->loopback.amplist)
18470 		spec->loopback.amplist = alc662_loopbacks;
18471 #endif
18472 
18473 	return 0;
18474 }
18475 
18476 static int patch_alc888(struct hda_codec *codec)
18477 {
18478 	if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
18479 		kfree(codec->chip_name);
18480 		codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
18481 		if (!codec->chip_name) {
18482 			alc_free(codec);
18483 			return -ENOMEM;
18484 		}
18485 		return patch_alc662(codec);
18486 	}
18487 	return patch_alc882(codec);
18488 }
18489 
18490 /*
18491  * patch entries
18492  */
18493 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18494 	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18495 	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18496 	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18497 	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18498 	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18499 	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18500 	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18501 	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18502 	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18503 	  .patch = patch_alc861 },
18504 	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18505 	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18506 	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18507 	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18508 	  .patch = patch_alc882 },
18509 	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18510 	  .patch = patch_alc662 },
18511 	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18512 	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
18513 	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
18514 	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18515 	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18516 	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18517 	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18518 	  .patch = patch_alc882 },
18519 	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18520 	  .patch = patch_alc882 },
18521 	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18522 	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18523 	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18524 	  .patch = patch_alc882 },
18525 	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18526 	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18527 	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18528 	{} /* terminator */
18529 };
18530 
18531 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18532 
18533 MODULE_LICENSE("GPL");
18534 MODULE_DESCRIPTION("Realtek HD-audio codec");
18535 
18536 static struct hda_codec_preset_list realtek_list = {
18537 	.preset = snd_hda_preset_realtek,
18538 	.owner = THIS_MODULE,
18539 };
18540 
18541 static int __init patch_realtek_init(void)
18542 {
18543 	return snd_hda_add_codec_preset(&realtek_list);
18544 }
18545 
18546 static void __exit patch_realtek_exit(void)
18547 {
18548 	snd_hda_delete_codec_preset(&realtek_list);
18549 }
18550 
18551 module_init(patch_realtek_init)
18552 module_exit(patch_realtek_exit)
18553