patch_realtek.c revision 265a02478db5217eda8063004ded1ef0a461c240 
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 <sound/jack.h>
32#include "hda_codec.h"
33#include "hda_local.h"
34#include "hda_beep.h"
35
36#define ALC880_FRONT_EVENT		0x01
37#define ALC880_DCVOL_EVENT		0x02
38#define ALC880_HP_EVENT			0x04
39#define ALC880_MIC_EVENT		0x08
40
41/* ALC880 board config type */
42enum {
43	ALC880_3ST,
44	ALC880_3ST_DIG,
45	ALC880_5ST,
46	ALC880_5ST_DIG,
47	ALC880_W810,
48	ALC880_Z71V,
49	ALC880_6ST,
50	ALC880_6ST_DIG,
51	ALC880_F1734,
52	ALC880_ASUS,
53	ALC880_ASUS_DIG,
54	ALC880_ASUS_W1V,
55	ALC880_ASUS_DIG2,
56	ALC880_FUJITSU,
57	ALC880_UNIWILL_DIG,
58	ALC880_UNIWILL,
59	ALC880_UNIWILL_P53,
60	ALC880_CLEVO,
61	ALC880_TCL_S700,
62	ALC880_LG,
63	ALC880_LG_LW,
64	ALC880_MEDION_RIM,
65#ifdef CONFIG_SND_DEBUG
66	ALC880_TEST,
67#endif
68	ALC880_AUTO,
69	ALC880_MODEL_LAST /* last tag */
70};
71
72/* ALC260 models */
73enum {
74	ALC260_BASIC,
75	ALC260_HP,
76	ALC260_HP_DC7600,
77	ALC260_HP_3013,
78	ALC260_FUJITSU_S702X,
79	ALC260_ACER,
80	ALC260_WILL,
81	ALC260_REPLACER_672V,
82	ALC260_FAVORIT100,
83#ifdef CONFIG_SND_DEBUG
84	ALC260_TEST,
85#endif
86	ALC260_AUTO,
87	ALC260_MODEL_LAST /* last tag */
88};
89
90/* ALC262 models */
91enum {
92	ALC262_BASIC,
93	ALC262_HIPPO,
94	ALC262_HIPPO_1,
95	ALC262_FUJITSU,
96	ALC262_HP_BPC,
97	ALC262_HP_BPC_D7000_WL,
98	ALC262_HP_BPC_D7000_WF,
99	ALC262_HP_TC_T5735,
100	ALC262_HP_RP5700,
101	ALC262_BENQ_ED8,
102	ALC262_SONY_ASSAMD,
103	ALC262_BENQ_T31,
104	ALC262_ULTRA,
105	ALC262_LENOVO_3000,
106	ALC262_NEC,
107	ALC262_TOSHIBA_S06,
108	ALC262_TOSHIBA_RX1,
109	ALC262_TYAN,
110	ALC262_AUTO,
111	ALC262_MODEL_LAST /* last tag */
112};
113
114/* ALC268 models */
115enum {
116	ALC267_QUANTA_IL1,
117	ALC268_3ST,
118	ALC268_TOSHIBA,
119	ALC268_ACER,
120	ALC268_ACER_DMIC,
121	ALC268_ACER_ASPIRE_ONE,
122	ALC268_DELL,
123	ALC268_ZEPTO,
124#ifdef CONFIG_SND_DEBUG
125	ALC268_TEST,
126#endif
127	ALC268_AUTO,
128	ALC268_MODEL_LAST /* last tag */
129};
130
131/* ALC269 models */
132enum {
133	ALC269_BASIC,
134	ALC269_QUANTA_FL1,
135	ALC269_AMIC,
136	ALC269_DMIC,
137	ALC269VB_AMIC,
138	ALC269VB_DMIC,
139	ALC269_FUJITSU,
140	ALC269_LIFEBOOK,
141	ALC271_ACER,
142	ALC269_AUTO,
143	ALC269_MODEL_LAST /* last tag */
144};
145
146/* ALC861 models */
147enum {
148	ALC861_3ST,
149	ALC660_3ST,
150	ALC861_3ST_DIG,
151	ALC861_6ST_DIG,
152	ALC861_UNIWILL_M31,
153	ALC861_TOSHIBA,
154	ALC861_ASUS,
155	ALC861_ASUS_LAPTOP,
156	ALC861_AUTO,
157	ALC861_MODEL_LAST,
158};
159
160/* ALC861-VD models */
161enum {
162	ALC660VD_3ST,
163	ALC660VD_3ST_DIG,
164	ALC660VD_ASUS_V1S,
165	ALC861VD_3ST,
166	ALC861VD_3ST_DIG,
167	ALC861VD_6ST_DIG,
168	ALC861VD_LENOVO,
169	ALC861VD_DALLAS,
170	ALC861VD_HP,
171	ALC861VD_AUTO,
172	ALC861VD_MODEL_LAST,
173};
174
175/* ALC662 models */
176enum {
177	ALC662_3ST_2ch_DIG,
178	ALC662_3ST_6ch_DIG,
179	ALC662_3ST_6ch,
180	ALC662_5ST_DIG,
181	ALC662_LENOVO_101E,
182	ALC662_ASUS_EEEPC_P701,
183	ALC662_ASUS_EEEPC_EP20,
184	ALC663_ASUS_M51VA,
185	ALC663_ASUS_G71V,
186	ALC663_ASUS_H13,
187	ALC663_ASUS_G50V,
188	ALC662_ECS,
189	ALC663_ASUS_MODE1,
190	ALC662_ASUS_MODE2,
191	ALC663_ASUS_MODE3,
192	ALC663_ASUS_MODE4,
193	ALC663_ASUS_MODE5,
194	ALC663_ASUS_MODE6,
195	ALC663_ASUS_MODE7,
196	ALC663_ASUS_MODE8,
197	ALC272_DELL,
198	ALC272_DELL_ZM1,
199	ALC272_SAMSUNG_NC10,
200	ALC662_AUTO,
201	ALC662_MODEL_LAST,
202};
203
204/* ALC882 models */
205enum {
206	ALC882_3ST_DIG,
207	ALC882_6ST_DIG,
208	ALC882_ARIMA,
209	ALC882_W2JC,
210	ALC882_TARGA,
211	ALC882_ASUS_A7J,
212	ALC882_ASUS_A7M,
213	ALC885_MACPRO,
214	ALC885_MBA21,
215	ALC885_MBP3,
216	ALC885_MB5,
217	ALC885_MACMINI3,
218	ALC885_IMAC24,
219	ALC885_IMAC91,
220	ALC883_3ST_2ch_DIG,
221	ALC883_3ST_6ch_DIG,
222	ALC883_3ST_6ch,
223	ALC883_6ST_DIG,
224	ALC883_TARGA_DIG,
225	ALC883_TARGA_2ch_DIG,
226	ALC883_TARGA_8ch_DIG,
227	ALC883_ACER,
228	ALC883_ACER_ASPIRE,
229	ALC888_ACER_ASPIRE_4930G,
230	ALC888_ACER_ASPIRE_6530G,
231	ALC888_ACER_ASPIRE_8930G,
232	ALC888_ACER_ASPIRE_7730G,
233	ALC883_MEDION,
234	ALC883_MEDION_MD2,
235	ALC883_MEDION_WIM2160,
236	ALC883_LAPTOP_EAPD,
237	ALC883_LENOVO_101E_2ch,
238	ALC883_LENOVO_NB0763,
239	ALC888_LENOVO_MS7195_DIG,
240	ALC888_LENOVO_SKY,
241	ALC883_HAIER_W66,
242	ALC888_3ST_HP,
243	ALC888_6ST_DELL,
244	ALC883_MITAC,
245	ALC883_CLEVO_M540R,
246	ALC883_CLEVO_M720,
247	ALC883_FUJITSU_PI2515,
248	ALC888_FUJITSU_XA3530,
249	ALC883_3ST_6ch_INTEL,
250	ALC889A_INTEL,
251	ALC889_INTEL,
252	ALC888_ASUS_M90V,
253	ALC888_ASUS_EEE1601,
254	ALC889A_MB31,
255	ALC1200_ASUS_P5Q,
256	ALC883_SONY_VAIO_TT,
257	ALC882_AUTO,
258	ALC882_MODEL_LAST,
259};
260
261/* ALC680 models */
262enum {
263	ALC680_BASE,
264	ALC680_AUTO,
265	ALC680_MODEL_LAST,
266};
267
268/* for GPIO Poll */
269#define GPIO_MASK	0x03
270
271/* extra amp-initialization sequence types */
272enum {
273	ALC_INIT_NONE,
274	ALC_INIT_DEFAULT,
275	ALC_INIT_GPIO1,
276	ALC_INIT_GPIO2,
277	ALC_INIT_GPIO3,
278};
279
280struct alc_mic_route {
281	hda_nid_t pin;
282	unsigned char mux_idx;
283	unsigned char amix_idx;
284};
285
286struct alc_jack {
287	hda_nid_t nid;
288	int type;
289	struct snd_jack *jack;
290};
291
292#define MUX_IDX_UNDEF	((unsigned char)-1)
293
294struct alc_customize_define {
295	unsigned int  sku_cfg;
296	unsigned char port_connectivity;
297	unsigned char check_sum;
298	unsigned char customization;
299	unsigned char external_amp;
300	unsigned int  enable_pcbeep:1;
301	unsigned int  platform_type:1;
302	unsigned int  swap:1;
303	unsigned int  override:1;
304};
305
306struct alc_spec {
307	/* codec parameterization */
308	struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
309	unsigned int num_mixers;
310	struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
311	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
312
313	const struct hda_verb *init_verbs[10];	/* initialization verbs
314						 * don't forget NULL
315						 * termination!
316						 */
317	unsigned int num_init_verbs;
318
319	char stream_name_analog[32];	/* analog PCM stream */
320	struct hda_pcm_stream *stream_analog_playback;
321	struct hda_pcm_stream *stream_analog_capture;
322	struct hda_pcm_stream *stream_analog_alt_playback;
323	struct hda_pcm_stream *stream_analog_alt_capture;
324
325	char stream_name_digital[32];	/* digital PCM stream */
326	struct hda_pcm_stream *stream_digital_playback;
327	struct hda_pcm_stream *stream_digital_capture;
328
329	/* playback */
330	struct hda_multi_out multiout;	/* playback set-up
331					 * max_channels, dacs must be set
332					 * dig_out_nid and hp_nid are optional
333					 */
334	hda_nid_t alt_dac_nid;
335	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
336	int dig_out_type;
337
338	/* capture */
339	unsigned int num_adc_nids;
340	hda_nid_t *adc_nids;
341	hda_nid_t *capsrc_nids;
342	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
343
344	/* capture setup for dynamic dual-adc switch */
345	unsigned int cur_adc_idx;
346	hda_nid_t cur_adc;
347	unsigned int cur_adc_stream_tag;
348	unsigned int cur_adc_format;
349
350	/* capture source */
351	unsigned int num_mux_defs;
352	const struct hda_input_mux *input_mux;
353	unsigned int cur_mux[3];
354	struct alc_mic_route ext_mic;
355	struct alc_mic_route int_mic;
356
357	/* channel model */
358	const struct hda_channel_mode *channel_mode;
359	int num_channel_mode;
360	int need_dac_fix;
361	int const_channel_count;
362	int ext_channel_count;
363
364	/* PCM information */
365	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
366
367	/* jack detection */
368	struct snd_array jacks;
369
370	/* dynamic controls, init_verbs and input_mux */
371	struct auto_pin_cfg autocfg;
372	struct alc_customize_define cdefine;
373	struct snd_array kctls;
374	struct hda_input_mux private_imux[3];
375	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
376	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
377	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
378
379	/* hooks */
380	void (*init_hook)(struct hda_codec *codec);
381	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
382#ifdef CONFIG_SND_HDA_POWER_SAVE
383	void (*power_hook)(struct hda_codec *codec);
384#endif
385
386	/* for pin sensing */
387	unsigned int sense_updated: 1;
388	unsigned int jack_present: 1;
389	unsigned int master_sw: 1;
390	unsigned int auto_mic:1;
391
392	/* other flags */
393	unsigned int no_analog :1; /* digital I/O only */
394	unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
395	int init_amp;
396	int codec_variant;	/* flag for other variants */
397
398	/* for virtual master */
399	hda_nid_t vmaster_nid;
400#ifdef CONFIG_SND_HDA_POWER_SAVE
401	struct hda_loopback_check loopback;
402#endif
403
404	/* for PLL fix */
405	hda_nid_t pll_nid;
406	unsigned int pll_coef_idx, pll_coef_bit;
407};
408
409/*
410 * configuration template - to be copied to the spec instance
411 */
412struct alc_config_preset {
413	struct snd_kcontrol_new *mixers[5]; /* should be identical size
414					     * with spec
415					     */
416	struct snd_kcontrol_new *cap_mixer; /* capture mixer */
417	const struct hda_verb *init_verbs[5];
418	unsigned int num_dacs;
419	hda_nid_t *dac_nids;
420	hda_nid_t dig_out_nid;		/* optional */
421	hda_nid_t hp_nid;		/* optional */
422	hda_nid_t *slave_dig_outs;
423	unsigned int num_adc_nids;
424	hda_nid_t *adc_nids;
425	hda_nid_t *capsrc_nids;
426	hda_nid_t dig_in_nid;
427	unsigned int num_channel_mode;
428	const struct hda_channel_mode *channel_mode;
429	int need_dac_fix;
430	int const_channel_count;
431	unsigned int num_mux_defs;
432	const struct hda_input_mux *input_mux;
433	void (*unsol_event)(struct hda_codec *, unsigned int);
434	void (*setup)(struct hda_codec *);
435	void (*init_hook)(struct hda_codec *);
436#ifdef CONFIG_SND_HDA_POWER_SAVE
437	struct hda_amp_list *loopbacks;
438	void (*power_hook)(struct hda_codec *codec);
439#endif
440};
441
442
443/*
444 * input MUX handling
445 */
446static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
447			     struct snd_ctl_elem_info *uinfo)
448{
449	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
450	struct alc_spec *spec = codec->spec;
451	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
452	if (mux_idx >= spec->num_mux_defs)
453		mux_idx = 0;
454	if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
455		mux_idx = 0;
456	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
457}
458
459static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
460			    struct snd_ctl_elem_value *ucontrol)
461{
462	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
463	struct alc_spec *spec = codec->spec;
464	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
465
466	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
467	return 0;
468}
469
470static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
471			    struct snd_ctl_elem_value *ucontrol)
472{
473	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
474	struct alc_spec *spec = codec->spec;
475	const struct hda_input_mux *imux;
476	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
477	unsigned int mux_idx;
478	hda_nid_t nid = spec->capsrc_nids ?
479		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
480	unsigned int type;
481
482	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
483	imux = &spec->input_mux[mux_idx];
484	if (!imux->num_items && mux_idx > 0)
485		imux = &spec->input_mux[0];
486
487	type = get_wcaps_type(get_wcaps(codec, nid));
488	if (type == AC_WID_AUD_MIX) {
489		/* Matrix-mixer style (e.g. ALC882) */
490		unsigned int *cur_val = &spec->cur_mux[adc_idx];
491		unsigned int i, idx;
492
493		idx = ucontrol->value.enumerated.item[0];
494		if (idx >= imux->num_items)
495			idx = imux->num_items - 1;
496		if (*cur_val == idx)
497			return 0;
498		for (i = 0; i < imux->num_items; i++) {
499			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
500			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
501						 imux->items[i].index,
502						 HDA_AMP_MUTE, v);
503		}
504		*cur_val = idx;
505		return 1;
506	} else {
507		/* MUX style (e.g. ALC880) */
508		return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
509					     &spec->cur_mux[adc_idx]);
510	}
511}
512
513/*
514 * channel mode setting
515 */
516static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
517			    struct snd_ctl_elem_info *uinfo)
518{
519	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
520	struct alc_spec *spec = codec->spec;
521	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
522				    spec->num_channel_mode);
523}
524
525static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
526			   struct snd_ctl_elem_value *ucontrol)
527{
528	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
529	struct alc_spec *spec = codec->spec;
530	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
531				   spec->num_channel_mode,
532				   spec->ext_channel_count);
533}
534
535static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
536			   struct snd_ctl_elem_value *ucontrol)
537{
538	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
539	struct alc_spec *spec = codec->spec;
540	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
541				      spec->num_channel_mode,
542				      &spec->ext_channel_count);
543	if (err >= 0 && !spec->const_channel_count) {
544		spec->multiout.max_channels = spec->ext_channel_count;
545		if (spec->need_dac_fix)
546			spec->multiout.num_dacs = spec->multiout.max_channels / 2;
547	}
548	return err;
549}
550
551/*
552 * Control the mode of pin widget settings via the mixer.  "pc" is used
553 * instead of "%" to avoid consequences of accidently treating the % as
554 * being part of a format specifier.  Maximum allowed length of a value is
555 * 63 characters plus NULL terminator.
556 *
557 * Note: some retasking pin complexes seem to ignore requests for input
558 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
559 * are requested.  Therefore order this list so that this behaviour will not
560 * cause problems when mixer clients move through the enum sequentially.
561 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
562 * March 2006.
563 */
564static char *alc_pin_mode_names[] = {
565	"Mic 50pc bias", "Mic 80pc bias",
566	"Line in", "Line out", "Headphone out",
567};
568static unsigned char alc_pin_mode_values[] = {
569	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
570};
571/* The control can present all 5 options, or it can limit the options based
572 * in the pin being assumed to be exclusively an input or an output pin.  In
573 * addition, "input" pins may or may not process the mic bias option
574 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
575 * accept requests for bias as of chip versions up to March 2006) and/or
576 * wiring in the computer.
577 */
578#define ALC_PIN_DIR_IN              0x00
579#define ALC_PIN_DIR_OUT             0x01
580#define ALC_PIN_DIR_INOUT           0x02
581#define ALC_PIN_DIR_IN_NOMICBIAS    0x03
582#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
583
584/* Info about the pin modes supported by the different pin direction modes.
585 * For each direction the minimum and maximum values are given.
586 */
587static signed char alc_pin_mode_dir_info[5][2] = {
588	{ 0, 2 },    /* ALC_PIN_DIR_IN */
589	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
590	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
591	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
592	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
593};
594#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
595#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
596#define alc_pin_mode_n_items(_dir) \
597	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
598
599static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
600			     struct snd_ctl_elem_info *uinfo)
601{
602	unsigned int item_num = uinfo->value.enumerated.item;
603	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
604
605	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
606	uinfo->count = 1;
607	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
608
609	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
610		item_num = alc_pin_mode_min(dir);
611	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
612	return 0;
613}
614
615static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
616			    struct snd_ctl_elem_value *ucontrol)
617{
618	unsigned int i;
619	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
620	hda_nid_t nid = kcontrol->private_value & 0xffff;
621	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
622	long *valp = ucontrol->value.integer.value;
623	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
624						 AC_VERB_GET_PIN_WIDGET_CONTROL,
625						 0x00);
626
627	/* Find enumerated value for current pinctl setting */
628	i = alc_pin_mode_min(dir);
629	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
630		i++;
631	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
632	return 0;
633}
634
635static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
636			    struct snd_ctl_elem_value *ucontrol)
637{
638	signed int change;
639	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
640	hda_nid_t nid = kcontrol->private_value & 0xffff;
641	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
642	long val = *ucontrol->value.integer.value;
643	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
644						 AC_VERB_GET_PIN_WIDGET_CONTROL,
645						 0x00);
646
647	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
648		val = alc_pin_mode_min(dir);
649
650	change = pinctl != alc_pin_mode_values[val];
651	if (change) {
652		/* Set pin mode to that requested */
653		snd_hda_codec_write_cache(codec, nid, 0,
654					  AC_VERB_SET_PIN_WIDGET_CONTROL,
655					  alc_pin_mode_values[val]);
656
657		/* Also enable the retasking pin's input/output as required
658		 * for the requested pin mode.  Enum values of 2 or less are
659		 * input modes.
660		 *
661		 * Dynamically switching the input/output buffers probably
662		 * reduces noise slightly (particularly on input) so we'll
663		 * do it.  However, having both input and output buffers
664		 * enabled simultaneously doesn't seem to be problematic if
665		 * this turns out to be necessary in the future.
666		 */
667		if (val <= 2) {
668			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
669						 HDA_AMP_MUTE, HDA_AMP_MUTE);
670			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
671						 HDA_AMP_MUTE, 0);
672		} else {
673			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
674						 HDA_AMP_MUTE, HDA_AMP_MUTE);
675			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
676						 HDA_AMP_MUTE, 0);
677		}
678	}
679	return change;
680}
681
682#define ALC_PIN_MODE(xname, nid, dir) \
683	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
684	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
685	  .info = alc_pin_mode_info, \
686	  .get = alc_pin_mode_get, \
687	  .put = alc_pin_mode_put, \
688	  .private_value = nid | (dir<<16) }
689
690/* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
691 * together using a mask with more than one bit set.  This control is
692 * currently used only by the ALC260 test model.  At this stage they are not
693 * needed for any "production" models.
694 */
695#ifdef CONFIG_SND_DEBUG
696#define alc_gpio_data_info	snd_ctl_boolean_mono_info
697
698static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
699			     struct snd_ctl_elem_value *ucontrol)
700{
701	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
702	hda_nid_t nid = kcontrol->private_value & 0xffff;
703	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
704	long *valp = ucontrol->value.integer.value;
705	unsigned int val = snd_hda_codec_read(codec, nid, 0,
706					      AC_VERB_GET_GPIO_DATA, 0x00);
707
708	*valp = (val & mask) != 0;
709	return 0;
710}
711static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
712			     struct snd_ctl_elem_value *ucontrol)
713{
714	signed int change;
715	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
716	hda_nid_t nid = kcontrol->private_value & 0xffff;
717	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
718	long val = *ucontrol->value.integer.value;
719	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
720						    AC_VERB_GET_GPIO_DATA,
721						    0x00);
722
723	/* Set/unset the masked GPIO bit(s) as needed */
724	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
725	if (val == 0)
726		gpio_data &= ~mask;
727	else
728		gpio_data |= mask;
729	snd_hda_codec_write_cache(codec, nid, 0,
730				  AC_VERB_SET_GPIO_DATA, gpio_data);
731
732	return change;
733}
734#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
735	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
736	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
737	  .info = alc_gpio_data_info, \
738	  .get = alc_gpio_data_get, \
739	  .put = alc_gpio_data_put, \
740	  .private_value = nid | (mask<<16) }
741#endif   /* CONFIG_SND_DEBUG */
742
743/* A switch control to allow the enabling of the digital IO pins on the
744 * ALC260.  This is incredibly simplistic; the intention of this control is
745 * to provide something in the test model allowing digital outputs to be
746 * identified if present.  If models are found which can utilise these
747 * outputs a more complete mixer control can be devised for those models if
748 * necessary.
749 */
750#ifdef CONFIG_SND_DEBUG
751#define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info
752
753static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
754			      struct snd_ctl_elem_value *ucontrol)
755{
756	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
757	hda_nid_t nid = kcontrol->private_value & 0xffff;
758	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
759	long *valp = ucontrol->value.integer.value;
760	unsigned int val = snd_hda_codec_read(codec, nid, 0,
761					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);
762
763	*valp = (val & mask) != 0;
764	return 0;
765}
766static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
767			      struct snd_ctl_elem_value *ucontrol)
768{
769	signed int change;
770	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
771	hda_nid_t nid = kcontrol->private_value & 0xffff;
772	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
773	long val = *ucontrol->value.integer.value;
774	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
775						    AC_VERB_GET_DIGI_CONVERT_1,
776						    0x00);
777
778	/* Set/unset the masked control bit(s) as needed */
779	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
780	if (val==0)
781		ctrl_data &= ~mask;
782	else
783		ctrl_data |= mask;
784	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
785				  ctrl_data);
786
787	return change;
788}
789#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
790	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
791	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
792	  .info = alc_spdif_ctrl_info, \
793	  .get = alc_spdif_ctrl_get, \
794	  .put = alc_spdif_ctrl_put, \
795	  .private_value = nid | (mask<<16) }
796#endif   /* CONFIG_SND_DEBUG */
797
798/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
799 * Again, this is only used in the ALC26x test models to help identify when
800 * the EAPD line must be asserted for features to work.
801 */
802#ifdef CONFIG_SND_DEBUG
803#define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info
804
805static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
806			      struct snd_ctl_elem_value *ucontrol)
807{
808	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
809	hda_nid_t nid = kcontrol->private_value & 0xffff;
810	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
811	long *valp = ucontrol->value.integer.value;
812	unsigned int val = snd_hda_codec_read(codec, nid, 0,
813					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);
814
815	*valp = (val & mask) != 0;
816	return 0;
817}
818
819static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
820			      struct snd_ctl_elem_value *ucontrol)
821{
822	int change;
823	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
824	hda_nid_t nid = kcontrol->private_value & 0xffff;
825	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
826	long val = *ucontrol->value.integer.value;
827	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
828						    AC_VERB_GET_EAPD_BTLENABLE,
829						    0x00);
830
831	/* Set/unset the masked control bit(s) as needed */
832	change = (!val ? 0 : mask) != (ctrl_data & mask);
833	if (!val)
834		ctrl_data &= ~mask;
835	else
836		ctrl_data |= mask;
837	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
838				  ctrl_data);
839
840	return change;
841}
842
843#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
844	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
845	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
846	  .info = alc_eapd_ctrl_info, \
847	  .get = alc_eapd_ctrl_get, \
848	  .put = alc_eapd_ctrl_put, \
849	  .private_value = nid | (mask<<16) }
850#endif   /* CONFIG_SND_DEBUG */
851
852/*
853 * set up the input pin config (depending on the given auto-pin type)
854 */
855static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
856			      int auto_pin_type)
857{
858	unsigned int val = PIN_IN;
859
860	if (auto_pin_type == AUTO_PIN_MIC) {
861		unsigned int pincap;
862		unsigned int oldval;
863		oldval = snd_hda_codec_read(codec, nid, 0,
864					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
865		pincap = snd_hda_query_pin_caps(codec, nid);
866		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
867		/* if the default pin setup is vref50, we give it priority */
868		if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
869			val = PIN_VREF80;
870		else if (pincap & AC_PINCAP_VREF_50)
871			val = PIN_VREF50;
872		else if (pincap & AC_PINCAP_VREF_100)
873			val = PIN_VREF100;
874		else if (pincap & AC_PINCAP_VREF_GRD)
875			val = PIN_VREFGRD;
876	}
877	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
878}
879
880static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
881{
882	struct alc_spec *spec = codec->spec;
883	struct auto_pin_cfg *cfg = &spec->autocfg;
884
885	if (!cfg->line_outs) {
886		while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
887		       cfg->line_out_pins[cfg->line_outs])
888			cfg->line_outs++;
889	}
890	if (!cfg->speaker_outs) {
891		while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
892		       cfg->speaker_pins[cfg->speaker_outs])
893			cfg->speaker_outs++;
894	}
895	if (!cfg->hp_outs) {
896		while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
897		       cfg->hp_pins[cfg->hp_outs])
898			cfg->hp_outs++;
899	}
900}
901
902/*
903 */
904static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
905{
906	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
907		return;
908	spec->mixers[spec->num_mixers++] = mix;
909}
910
911static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
912{
913	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
914		return;
915	spec->init_verbs[spec->num_init_verbs++] = verb;
916}
917
918/*
919 * set up from the preset table
920 */
921static void setup_preset(struct hda_codec *codec,
922			 const struct alc_config_preset *preset)
923{
924	struct alc_spec *spec = codec->spec;
925	int i;
926
927	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
928		add_mixer(spec, preset->mixers[i]);
929	spec->cap_mixer = preset->cap_mixer;
930	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
931	     i++)
932		add_verb(spec, preset->init_verbs[i]);
933
934	spec->channel_mode = preset->channel_mode;
935	spec->num_channel_mode = preset->num_channel_mode;
936	spec->need_dac_fix = preset->need_dac_fix;
937	spec->const_channel_count = preset->const_channel_count;
938
939	if (preset->const_channel_count)
940		spec->multiout.max_channels = preset->const_channel_count;
941	else
942		spec->multiout.max_channels = spec->channel_mode[0].channels;
943	spec->ext_channel_count = spec->channel_mode[0].channels;
944
945	spec->multiout.num_dacs = preset->num_dacs;
946	spec->multiout.dac_nids = preset->dac_nids;
947	spec->multiout.dig_out_nid = preset->dig_out_nid;
948	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
949	spec->multiout.hp_nid = preset->hp_nid;
950
951	spec->num_mux_defs = preset->num_mux_defs;
952	if (!spec->num_mux_defs)
953		spec->num_mux_defs = 1;
954	spec->input_mux = preset->input_mux;
955
956	spec->num_adc_nids = preset->num_adc_nids;
957	spec->adc_nids = preset->adc_nids;
958	spec->capsrc_nids = preset->capsrc_nids;
959	spec->dig_in_nid = preset->dig_in_nid;
960
961	spec->unsol_event = preset->unsol_event;
962	spec->init_hook = preset->init_hook;
963#ifdef CONFIG_SND_HDA_POWER_SAVE
964	spec->power_hook = preset->power_hook;
965	spec->loopback.amplist = preset->loopbacks;
966#endif
967
968	if (preset->setup)
969		preset->setup(codec);
970
971	alc_fixup_autocfg_pin_nums(codec);
972}
973
974/* Enable GPIO mask and set output */
975static struct hda_verb alc_gpio1_init_verbs[] = {
976	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
977	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
978	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
979	{ }
980};
981
982static struct hda_verb alc_gpio2_init_verbs[] = {
983	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
984	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
985	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
986	{ }
987};
988
989static struct hda_verb alc_gpio3_init_verbs[] = {
990	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
991	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
992	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
993	{ }
994};
995
996/*
997 * Fix hardware PLL issue
998 * On some codecs, the analog PLL gating control must be off while
999 * the default value is 1.
1000 */
1001static void alc_fix_pll(struct hda_codec *codec)
1002{
1003	struct alc_spec *spec = codec->spec;
1004	unsigned int val;
1005
1006	if (!spec->pll_nid)
1007		return;
1008	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1009			    spec->pll_coef_idx);
1010	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1011				 AC_VERB_GET_PROC_COEF, 0);
1012	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1013			    spec->pll_coef_idx);
1014	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1015			    val & ~(1 << spec->pll_coef_bit));
1016}
1017
1018static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1019			     unsigned int coef_idx, unsigned int coef_bit)
1020{
1021	struct alc_spec *spec = codec->spec;
1022	spec->pll_nid = nid;
1023	spec->pll_coef_idx = coef_idx;
1024	spec->pll_coef_bit = coef_bit;
1025	alc_fix_pll(codec);
1026}
1027
1028#ifdef CONFIG_SND_HDA_INPUT_JACK
1029static void alc_free_jack_priv(struct snd_jack *jack)
1030{
1031	struct alc_jack *jacks = jack->private_data;
1032	jacks->nid = 0;
1033	jacks->jack = NULL;
1034}
1035
1036static int alc_add_jack(struct hda_codec *codec,
1037		hda_nid_t nid, int type)
1038{
1039	struct alc_spec *spec;
1040	struct alc_jack *jack;
1041	const char *name;
1042	int err;
1043
1044	spec = codec->spec;
1045	snd_array_init(&spec->jacks, sizeof(*jack), 32);
1046	jack = snd_array_new(&spec->jacks);
1047	if (!jack)
1048		return -ENOMEM;
1049
1050	jack->nid = nid;
1051	jack->type = type;
1052	name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
1053
1054	err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
1055	if (err < 0)
1056		return err;
1057	jack->jack->private_data = jack;
1058	jack->jack->private_free = alc_free_jack_priv;
1059	return 0;
1060}
1061
1062static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1063{
1064	struct alc_spec *spec = codec->spec;
1065	struct alc_jack *jacks = spec->jacks.list;
1066
1067	if (jacks) {
1068		int i;
1069		for (i = 0; i < spec->jacks.used; i++) {
1070			if (jacks->nid == nid) {
1071				unsigned int present;
1072				present = snd_hda_jack_detect(codec, nid);
1073
1074				present = (present) ? jacks->type : 0;
1075
1076				snd_jack_report(jacks->jack, present);
1077			}
1078			jacks++;
1079		}
1080	}
1081}
1082
1083static int alc_init_jacks(struct hda_codec *codec)
1084{
1085	struct alc_spec *spec = codec->spec;
1086	int err;
1087	unsigned int hp_nid = spec->autocfg.hp_pins[0];
1088	unsigned int mic_nid = spec->ext_mic.pin;
1089
1090	if (hp_nid) {
1091		err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1092		if (err < 0)
1093			return err;
1094		alc_report_jack(codec, hp_nid);
1095	}
1096
1097	if (mic_nid) {
1098		err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1099		if (err < 0)
1100			return err;
1101		alc_report_jack(codec, mic_nid);
1102	}
1103
1104	return 0;
1105}
1106#else
1107static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1108{
1109}
1110
1111static inline int alc_init_jacks(struct hda_codec *codec)
1112{
1113	return 0;
1114}
1115#endif
1116
1117static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1118{
1119	struct alc_spec *spec = codec->spec;
1120	unsigned int mute;
1121	hda_nid_t nid;
1122	int i;
1123
1124	spec->jack_present = 0;
1125	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1126		nid = spec->autocfg.hp_pins[i];
1127		if (!nid)
1128			break;
1129		if (snd_hda_jack_detect(codec, nid)) {
1130			spec->jack_present = 1;
1131			break;
1132		}
1133		alc_report_jack(codec, spec->autocfg.hp_pins[i]);
1134	}
1135
1136	mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1137	/* Toggle internal speakers muting */
1138	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1139		nid = spec->autocfg.speaker_pins[i];
1140		if (!nid)
1141			break;
1142		if (pinctl) {
1143			snd_hda_codec_write(codec, nid, 0,
1144				    AC_VERB_SET_PIN_WIDGET_CONTROL,
1145				    spec->jack_present ? 0 : PIN_OUT);
1146		} else {
1147			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1148					 HDA_AMP_MUTE, mute);
1149		}
1150	}
1151}
1152
1153static void alc_automute_pin(struct hda_codec *codec)
1154{
1155	alc_automute_speaker(codec, 1);
1156}
1157
1158static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1159				hda_nid_t nid)
1160{
1161	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1162	int i, nums;
1163
1164	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1165	for (i = 0; i < nums; i++)
1166		if (conn[i] == nid)
1167			return i;
1168	return -1;
1169}
1170
1171/* switch the current ADC according to the jack state */
1172static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1173{
1174	struct alc_spec *spec = codec->spec;
1175	unsigned int present;
1176	hda_nid_t new_adc;
1177
1178	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1179	if (present)
1180		spec->cur_adc_idx = 1;
1181	else
1182		spec->cur_adc_idx = 0;
1183	new_adc = spec->adc_nids[spec->cur_adc_idx];
1184	if (spec->cur_adc && spec->cur_adc != new_adc) {
1185		/* stream is running, let's swap the current ADC */
1186		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1187		spec->cur_adc = new_adc;
1188		snd_hda_codec_setup_stream(codec, new_adc,
1189					   spec->cur_adc_stream_tag, 0,
1190					   spec->cur_adc_format);
1191	}
1192}
1193
1194static void alc_mic_automute(struct hda_codec *codec)
1195{
1196	struct alc_spec *spec = codec->spec;
1197	struct alc_mic_route *dead, *alive;
1198	unsigned int present, type;
1199	hda_nid_t cap_nid;
1200
1201	if (!spec->auto_mic)
1202		return;
1203	if (!spec->int_mic.pin || !spec->ext_mic.pin)
1204		return;
1205	if (snd_BUG_ON(!spec->adc_nids))
1206		return;
1207
1208	if (spec->dual_adc_switch) {
1209		alc_dual_mic_adc_auto_switch(codec);
1210		return;
1211	}
1212
1213	cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1214
1215	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1216	if (present) {
1217		alive = &spec->ext_mic;
1218		dead = &spec->int_mic;
1219	} else {
1220		alive = &spec->int_mic;
1221		dead = &spec->ext_mic;
1222	}
1223
1224	type = get_wcaps_type(get_wcaps(codec, cap_nid));
1225	if (type == AC_WID_AUD_MIX) {
1226		/* Matrix-mixer style (e.g. ALC882) */
1227		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1228					 alive->mux_idx,
1229					 HDA_AMP_MUTE, 0);
1230		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1231					 dead->mux_idx,
1232					 HDA_AMP_MUTE, HDA_AMP_MUTE);
1233	} else {
1234		/* MUX style (e.g. ALC880) */
1235		snd_hda_codec_write_cache(codec, cap_nid, 0,
1236					  AC_VERB_SET_CONNECT_SEL,
1237					  alive->mux_idx);
1238	}
1239	alc_report_jack(codec, spec->ext_mic.pin);
1240
1241	/* FIXME: analog mixer */
1242}
1243
1244/* unsolicited event for HP jack sensing */
1245static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1246{
1247	if (codec->vendor_id == 0x10ec0880)
1248		res >>= 28;
1249	else
1250		res >>= 26;
1251	switch (res) {
1252	case ALC880_HP_EVENT:
1253		alc_automute_pin(codec);
1254		break;
1255	case ALC880_MIC_EVENT:
1256		alc_mic_automute(codec);
1257		break;
1258	}
1259}
1260
1261static void alc_inithook(struct hda_codec *codec)
1262{
1263	alc_automute_pin(codec);
1264	alc_mic_automute(codec);
1265}
1266
1267/* additional initialization for ALC888 variants */
1268static void alc888_coef_init(struct hda_codec *codec)
1269{
1270	unsigned int tmp;
1271
1272	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1273	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1274	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1275	if ((tmp & 0xf0) == 0x20)
1276		/* alc888S-VC */
1277		snd_hda_codec_read(codec, 0x20, 0,
1278				   AC_VERB_SET_PROC_COEF, 0x830);
1279	 else
1280		 /* alc888-VB */
1281		 snd_hda_codec_read(codec, 0x20, 0,
1282				    AC_VERB_SET_PROC_COEF, 0x3030);
1283}
1284
1285static void alc889_coef_init(struct hda_codec *codec)
1286{
1287	unsigned int tmp;
1288
1289	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1290	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1291	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1292	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1293}
1294
1295/* turn on/off EAPD control (only if available) */
1296static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1297{
1298	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1299		return;
1300	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1301		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1302				    on ? 2 : 0);
1303}
1304
1305static void alc_auto_init_amp(struct hda_codec *codec, int type)
1306{
1307	unsigned int tmp;
1308
1309	switch (type) {
1310	case ALC_INIT_GPIO1:
1311		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1312		break;
1313	case ALC_INIT_GPIO2:
1314		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1315		break;
1316	case ALC_INIT_GPIO3:
1317		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1318		break;
1319	case ALC_INIT_DEFAULT:
1320		switch (codec->vendor_id) {
1321		case 0x10ec0260:
1322			set_eapd(codec, 0x0f, 1);
1323			set_eapd(codec, 0x10, 1);
1324			break;
1325		case 0x10ec0262:
1326		case 0x10ec0267:
1327		case 0x10ec0268:
1328		case 0x10ec0269:
1329		case 0x10ec0270:
1330		case 0x10ec0272:
1331		case 0x10ec0660:
1332		case 0x10ec0662:
1333		case 0x10ec0663:
1334		case 0x10ec0862:
1335		case 0x10ec0889:
1336			set_eapd(codec, 0x14, 1);
1337			set_eapd(codec, 0x15, 1);
1338			break;
1339		}
1340		switch (codec->vendor_id) {
1341		case 0x10ec0260:
1342			snd_hda_codec_write(codec, 0x1a, 0,
1343					    AC_VERB_SET_COEF_INDEX, 7);
1344			tmp = snd_hda_codec_read(codec, 0x1a, 0,
1345						 AC_VERB_GET_PROC_COEF, 0);
1346			snd_hda_codec_write(codec, 0x1a, 0,
1347					    AC_VERB_SET_COEF_INDEX, 7);
1348			snd_hda_codec_write(codec, 0x1a, 0,
1349					    AC_VERB_SET_PROC_COEF,
1350					    tmp | 0x2010);
1351			break;
1352		case 0x10ec0262:
1353		case 0x10ec0880:
1354		case 0x10ec0882:
1355		case 0x10ec0883:
1356		case 0x10ec0885:
1357		case 0x10ec0887:
1358		case 0x10ec0889:
1359			alc889_coef_init(codec);
1360			break;
1361		case 0x10ec0888:
1362			alc888_coef_init(codec);
1363			break;
1364#if 0 /* XXX: This may cause the silent output on speaker on some machines */
1365		case 0x10ec0267:
1366		case 0x10ec0268:
1367			snd_hda_codec_write(codec, 0x20, 0,
1368					    AC_VERB_SET_COEF_INDEX, 7);
1369			tmp = snd_hda_codec_read(codec, 0x20, 0,
1370						 AC_VERB_GET_PROC_COEF, 0);
1371			snd_hda_codec_write(codec, 0x20, 0,
1372					    AC_VERB_SET_COEF_INDEX, 7);
1373			snd_hda_codec_write(codec, 0x20, 0,
1374					    AC_VERB_SET_PROC_COEF,
1375					    tmp | 0x3000);
1376			break;
1377#endif /* XXX */
1378		}
1379		break;
1380	}
1381}
1382
1383static void alc_init_auto_hp(struct hda_codec *codec)
1384{
1385	struct alc_spec *spec = codec->spec;
1386	struct auto_pin_cfg *cfg = &spec->autocfg;
1387	int i;
1388
1389	if (!cfg->hp_pins[0]) {
1390		if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1391			return;
1392	}
1393
1394	if (!cfg->speaker_pins[0]) {
1395		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1396			return;
1397		memcpy(cfg->speaker_pins, cfg->line_out_pins,
1398		       sizeof(cfg->speaker_pins));
1399		cfg->speaker_outs = cfg->line_outs;
1400	}
1401
1402	if (!cfg->hp_pins[0]) {
1403		memcpy(cfg->hp_pins, cfg->line_out_pins,
1404		       sizeof(cfg->hp_pins));
1405		cfg->hp_outs = cfg->line_outs;
1406	}
1407
1408	for (i = 0; i < cfg->hp_outs; i++) {
1409		snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1410			    cfg->hp_pins[i]);
1411		snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1412				  AC_VERB_SET_UNSOLICITED_ENABLE,
1413				  AC_USRSP_EN | ALC880_HP_EVENT);
1414	}
1415	spec->unsol_event = alc_sku_unsol_event;
1416}
1417
1418static void alc_init_auto_mic(struct hda_codec *codec)
1419{
1420	struct alc_spec *spec = codec->spec;
1421	struct auto_pin_cfg *cfg = &spec->autocfg;
1422	hda_nid_t fixed, ext;
1423	int i;
1424
1425	/* there must be only two mic inputs exclusively */
1426	for (i = 0; i < cfg->num_inputs; i++)
1427		if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1428			return;
1429
1430	fixed = ext = 0;
1431	for (i = 0; i < cfg->num_inputs; i++) {
1432		hda_nid_t nid = cfg->inputs[i].pin;
1433		unsigned int defcfg;
1434		defcfg = snd_hda_codec_get_pincfg(codec, nid);
1435		switch (snd_hda_get_input_pin_attr(defcfg)) {
1436		case INPUT_PIN_ATTR_INT:
1437			if (fixed)
1438				return; /* already occupied */
1439			fixed = nid;
1440			break;
1441		case INPUT_PIN_ATTR_UNUSED:
1442			return; /* invalid entry */
1443		default:
1444			if (ext)
1445				return; /* already occupied */
1446			ext = nid;
1447			break;
1448		}
1449	}
1450	if (!ext || !fixed)
1451		return;
1452	if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1453		return; /* no unsol support */
1454	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1455		    ext, fixed);
1456	spec->ext_mic.pin = ext;
1457	spec->int_mic.pin = fixed;
1458	spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1459	spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1460	spec->auto_mic = 1;
1461	snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1462				  AC_VERB_SET_UNSOLICITED_ENABLE,
1463				  AC_USRSP_EN | ALC880_MIC_EVENT);
1464	spec->unsol_event = alc_sku_unsol_event;
1465}
1466
1467static int alc_auto_parse_customize_define(struct hda_codec *codec)
1468{
1469	unsigned int ass, tmp, i;
1470	unsigned nid = 0;
1471	struct alc_spec *spec = codec->spec;
1472
1473	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1474
1475	ass = codec->subsystem_id & 0xffff;
1476	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1477		goto do_sku;
1478
1479	nid = 0x1d;
1480	if (codec->vendor_id == 0x10ec0260)
1481		nid = 0x17;
1482	ass = snd_hda_codec_get_pincfg(codec, nid);
1483
1484	if (!(ass & 1)) {
1485		printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1486		       codec->chip_name, ass);
1487		return -1;
1488	}
1489
1490	/* check sum */
1491	tmp = 0;
1492	for (i = 1; i < 16; i++) {
1493		if ((ass >> i) & 1)
1494			tmp++;
1495	}
1496	if (((ass >> 16) & 0xf) != tmp)
1497		return -1;
1498
1499	spec->cdefine.port_connectivity = ass >> 30;
1500	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1501	spec->cdefine.check_sum = (ass >> 16) & 0xf;
1502	spec->cdefine.customization = ass >> 8;
1503do_sku:
1504	spec->cdefine.sku_cfg = ass;
1505	spec->cdefine.external_amp = (ass & 0x38) >> 3;
1506	spec->cdefine.platform_type = (ass & 0x4) >> 2;
1507	spec->cdefine.swap = (ass & 0x2) >> 1;
1508	spec->cdefine.override = ass & 0x1;
1509
1510	snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1511		   nid, spec->cdefine.sku_cfg);
1512	snd_printd("SKU: port_connectivity=0x%x\n",
1513		   spec->cdefine.port_connectivity);
1514	snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1515	snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1516	snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1517	snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1518	snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1519	snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1520	snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1521
1522	return 0;
1523}
1524
1525/* check subsystem ID and set up device-specific initialization;
1526 * return 1 if initialized, 0 if invalid SSID
1527 */
1528/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1529 *	31 ~ 16 :	Manufacture ID
1530 *	15 ~ 8	:	SKU ID
1531 *	7  ~ 0	:	Assembly ID
1532 *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1533 */
1534static int alc_subsystem_id(struct hda_codec *codec,
1535			    hda_nid_t porta, hda_nid_t porte,
1536			    hda_nid_t portd, hda_nid_t porti)
1537{
1538	unsigned int ass, tmp, i;
1539	unsigned nid;
1540	struct alc_spec *spec = codec->spec;
1541
1542	ass = codec->subsystem_id & 0xffff;
1543	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1544		goto do_sku;
1545
1546	/* invalid SSID, check the special NID pin defcfg instead */
1547	/*
1548	 * 31~30	: port connectivity
1549	 * 29~21	: reserve
1550	 * 20		: PCBEEP input
1551	 * 19~16	: Check sum (15:1)
1552	 * 15~1		: Custom
1553	 * 0		: override
1554	*/
1555	nid = 0x1d;
1556	if (codec->vendor_id == 0x10ec0260)
1557		nid = 0x17;
1558	ass = snd_hda_codec_get_pincfg(codec, nid);
1559	snd_printd("realtek: No valid SSID, "
1560		   "checking pincfg 0x%08x for NID 0x%x\n",
1561		   ass, nid);
1562	if (!(ass & 1))
1563		return 0;
1564	if ((ass >> 30) != 1)	/* no physical connection */
1565		return 0;
1566
1567	/* check sum */
1568	tmp = 0;
1569	for (i = 1; i < 16; i++) {
1570		if ((ass >> i) & 1)
1571			tmp++;
1572	}
1573	if (((ass >> 16) & 0xf) != tmp)
1574		return 0;
1575do_sku:
1576	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1577		   ass & 0xffff, codec->vendor_id);
1578	/*
1579	 * 0 : override
1580	 * 1 :	Swap Jack
1581	 * 2 : 0 --> Desktop, 1 --> Laptop
1582	 * 3~5 : External Amplifier control
1583	 * 7~6 : Reserved
1584	*/
1585	tmp = (ass & 0x38) >> 3;	/* external Amp control */
1586	switch (tmp) {
1587	case 1:
1588		spec->init_amp = ALC_INIT_GPIO1;
1589		break;
1590	case 3:
1591		spec->init_amp = ALC_INIT_GPIO2;
1592		break;
1593	case 7:
1594		spec->init_amp = ALC_INIT_GPIO3;
1595		break;
1596	case 5:
1597		spec->init_amp = ALC_INIT_DEFAULT;
1598		break;
1599	}
1600
1601	/* is laptop or Desktop and enable the function "Mute internal speaker
1602	 * when the external headphone out jack is plugged"
1603	 */
1604	if (!(ass & 0x8000))
1605		return 1;
1606	/*
1607	 * 10~8 : Jack location
1608	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1609	 * 14~13: Resvered
1610	 * 15   : 1 --> enable the function "Mute internal speaker
1611	 *	        when the external headphone out jack is plugged"
1612	 */
1613	if (!spec->autocfg.hp_pins[0]) {
1614		hda_nid_t nid;
1615		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
1616		if (tmp == 0)
1617			nid = porta;
1618		else if (tmp == 1)
1619			nid = porte;
1620		else if (tmp == 2)
1621			nid = portd;
1622		else if (tmp == 3)
1623			nid = porti;
1624		else
1625			return 1;
1626		for (i = 0; i < spec->autocfg.line_outs; i++)
1627			if (spec->autocfg.line_out_pins[i] == nid)
1628				return 1;
1629		spec->autocfg.hp_pins[0] = nid;
1630	}
1631
1632	alc_init_auto_hp(codec);
1633	alc_init_auto_mic(codec);
1634	return 1;
1635}
1636
1637static void alc_ssid_check(struct hda_codec *codec,
1638			   hda_nid_t porta, hda_nid_t porte,
1639			   hda_nid_t portd, hda_nid_t porti)
1640{
1641	if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1642		struct alc_spec *spec = codec->spec;
1643		snd_printd("realtek: "
1644			   "Enable default setup for auto mode as fallback\n");
1645		spec->init_amp = ALC_INIT_DEFAULT;
1646		alc_init_auto_hp(codec);
1647		alc_init_auto_mic(codec);
1648	}
1649}
1650
1651/*
1652 * Fix-up pin default configurations and add default verbs
1653 */
1654
1655struct alc_pincfg {
1656	hda_nid_t nid;
1657	u32 val;
1658};
1659
1660struct alc_fixup {
1661	const struct alc_pincfg *pins;
1662	const struct hda_verb *verbs;
1663};
1664
1665static void alc_pick_fixup(struct hda_codec *codec,
1666			   const struct snd_pci_quirk *quirk,
1667			   const struct alc_fixup *fix,
1668			   int pre_init)
1669{
1670	const struct alc_pincfg *cfg;
1671
1672	quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1673	if (!quirk)
1674		return;
1675	fix += quirk->value;
1676	cfg = fix->pins;
1677	if (pre_init && cfg) {
1678#ifdef CONFIG_SND_DEBUG_VERBOSE
1679		snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
1680			    codec->chip_name, quirk->name);
1681#endif
1682		for (; cfg->nid; cfg++)
1683			snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1684	}
1685	if (!pre_init && fix->verbs) {
1686#ifdef CONFIG_SND_DEBUG_VERBOSE
1687		snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
1688			    codec->chip_name, quirk->name);
1689#endif
1690		add_verb(codec->spec, fix->verbs);
1691	}
1692}
1693
1694static int alc_read_coef_idx(struct hda_codec *codec,
1695			unsigned int coef_idx)
1696{
1697	unsigned int val;
1698	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1699		    		coef_idx);
1700	val = snd_hda_codec_read(codec, 0x20, 0,
1701			 	AC_VERB_GET_PROC_COEF, 0);
1702	return val;
1703}
1704
1705static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1706							unsigned int coef_val)
1707{
1708	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1709			    coef_idx);
1710	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1711			    coef_val);
1712}
1713
1714/* set right pin controls for digital I/O */
1715static void alc_auto_init_digital(struct hda_codec *codec)
1716{
1717	struct alc_spec *spec = codec->spec;
1718	int i;
1719	hda_nid_t pin;
1720
1721	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1722		pin = spec->autocfg.dig_out_pins[i];
1723		if (pin) {
1724			snd_hda_codec_write(codec, pin, 0,
1725					    AC_VERB_SET_PIN_WIDGET_CONTROL,
1726					    PIN_OUT);
1727		}
1728	}
1729	pin = spec->autocfg.dig_in_pin;
1730	if (pin)
1731		snd_hda_codec_write(codec, pin, 0,
1732				    AC_VERB_SET_PIN_WIDGET_CONTROL,
1733				    PIN_IN);
1734}
1735
1736/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1737static void alc_auto_parse_digital(struct hda_codec *codec)
1738{
1739	struct alc_spec *spec = codec->spec;
1740	int i, err;
1741	hda_nid_t dig_nid;
1742
1743	/* support multiple SPDIFs; the secondary is set up as a slave */
1744	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1745		err = snd_hda_get_connections(codec,
1746					      spec->autocfg.dig_out_pins[i],
1747					      &dig_nid, 1);
1748		if (err < 0)
1749			continue;
1750		if (!i) {
1751			spec->multiout.dig_out_nid = dig_nid;
1752			spec->dig_out_type = spec->autocfg.dig_out_type[0];
1753		} else {
1754			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1755			if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1756				break;
1757			spec->slave_dig_outs[i - 1] = dig_nid;
1758		}
1759	}
1760
1761	if (spec->autocfg.dig_in_pin) {
1762		hda_nid_t dig_nid;
1763		err = snd_hda_get_connections(codec,
1764					      spec->autocfg.dig_in_pin,
1765					      &dig_nid, 1);
1766		if (err > 0)
1767			spec->dig_in_nid = dig_nid;
1768	}
1769}
1770
1771/*
1772 * ALC888
1773 */
1774
1775/*
1776 * 2ch mode
1777 */
1778static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1779/* Mic-in jack as mic in */
1780	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1781	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1782/* Line-in jack as Line in */
1783	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1784	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1785/* Line-Out as Front */
1786	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1787	{ } /* end */
1788};
1789
1790/*
1791 * 4ch mode
1792 */
1793static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1794/* Mic-in jack as mic in */
1795	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1796	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1797/* Line-in jack as Surround */
1798	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1799	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1800/* Line-Out as Front */
1801	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1802	{ } /* end */
1803};
1804
1805/*
1806 * 6ch mode
1807 */
1808static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1809/* Mic-in jack as CLFE */
1810	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1811	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1812/* Line-in jack as Surround */
1813	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1814	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1815/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1816	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1817	{ } /* end */
1818};
1819
1820/*
1821 * 8ch mode
1822 */
1823static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1824/* Mic-in jack as CLFE */
1825	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1826	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1827/* Line-in jack as Surround */
1828	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1829	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1830/* Line-Out as Side */
1831	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1832	{ } /* end */
1833};
1834
1835static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1836	{ 2, alc888_4ST_ch2_intel_init },
1837	{ 4, alc888_4ST_ch4_intel_init },
1838	{ 6, alc888_4ST_ch6_intel_init },
1839	{ 8, alc888_4ST_ch8_intel_init },
1840};
1841
1842/*
1843 * ALC888 Fujitsu Siemens Amillo xa3530
1844 */
1845
1846static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1847/* Front Mic: set to PIN_IN (empty by default) */
1848	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1849/* Connect Internal HP to Front */
1850	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1851	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1852	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1853/* Connect Bass HP to Front */
1854	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1855	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1856	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1857/* Connect Line-Out side jack (SPDIF) to Side */
1858	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1859	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1860	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1861/* Connect Mic jack to CLFE */
1862	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1863	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1864	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1865/* Connect Line-in jack to Surround */
1866	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1867	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1868	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1869/* Connect HP out jack to Front */
1870	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1871	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1872	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1873/* Enable unsolicited event for HP jack and Line-out jack */
1874	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1875	{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1876	{}
1877};
1878
1879static void alc_automute_amp(struct hda_codec *codec)
1880{
1881	alc_automute_speaker(codec, 0);
1882}
1883
1884static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1885					 unsigned int res)
1886{
1887	if (codec->vendor_id == 0x10ec0880)
1888		res >>= 28;
1889	else
1890		res >>= 26;
1891	if (res == ALC880_HP_EVENT)
1892		alc_automute_amp(codec);
1893}
1894
1895static void alc889_automute_setup(struct hda_codec *codec)
1896{
1897	struct alc_spec *spec = codec->spec;
1898
1899	spec->autocfg.hp_pins[0] = 0x15;
1900	spec->autocfg.speaker_pins[0] = 0x14;
1901	spec->autocfg.speaker_pins[1] = 0x16;
1902	spec->autocfg.speaker_pins[2] = 0x17;
1903	spec->autocfg.speaker_pins[3] = 0x19;
1904	spec->autocfg.speaker_pins[4] = 0x1a;
1905}
1906
1907static void alc889_intel_init_hook(struct hda_codec *codec)
1908{
1909	alc889_coef_init(codec);
1910	alc_automute_amp(codec);
1911}
1912
1913static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1914{
1915	struct alc_spec *spec = codec->spec;
1916
1917	spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1918	spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1919	spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1920	spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1921}
1922
1923/*
1924 * ALC888 Acer Aspire 4930G model
1925 */
1926
1927static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1928/* Front Mic: set to PIN_IN (empty by default) */
1929	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1930/* Unselect Front Mic by default in input mixer 3 */
1931	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1932/* Enable unsolicited event for HP jack */
1933	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1934/* Connect Internal HP to front */
1935	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1936	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1937	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1938/* Connect HP out to front */
1939	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1940	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1941	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1942	{ }
1943};
1944
1945/*
1946 * ALC888 Acer Aspire 6530G model
1947 */
1948
1949static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1950/* Route to built-in subwoofer as well as speakers */
1951	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1952	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1953	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1954	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1955/* Bias voltage on for external mic port */
1956	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1957/* Front Mic: set to PIN_IN (empty by default) */
1958	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1959/* Unselect Front Mic by default in input mixer 3 */
1960	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1961/* Enable unsolicited event for HP jack */
1962	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1963/* Enable speaker output */
1964	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1965	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1966	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
1967/* Enable headphone output */
1968	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1969	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1970	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1971	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
1972	{ }
1973};
1974
1975/*
1976 * ALC889 Acer Aspire 8930G model
1977 */
1978
1979static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1980/* Front Mic: set to PIN_IN (empty by default) */
1981	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1982/* Unselect Front Mic by default in input mixer 3 */
1983	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1984/* Enable unsolicited event for HP jack */
1985	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1986/* Connect Internal Front to Front */
1987	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1988	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1989	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1990/* Connect Internal Rear to Rear */
1991	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1992	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1993	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1994/* Connect Internal CLFE to CLFE */
1995	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1996	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1997	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1998/* Connect HP out to Front */
1999	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2000	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2001	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2002/* Enable all DACs */
2003/*  DAC DISABLE/MUTE 1? */
2004/*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2005	{0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2006	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2007/*  DAC DISABLE/MUTE 2? */
2008/*  some bit here disables the other DACs. Init=0x4900 */
2009	{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2010	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2011/* DMIC fix
2012 * This laptop has a stereo digital microphone. The mics are only 1cm apart
2013 * which makes the stereo useless. However, either the mic or the ALC889
2014 * makes the signal become a difference/sum signal instead of standard
2015 * stereo, which is annoying. So instead we flip this bit which makes the
2016 * codec replicate the sum signal to both channels, turning it into a
2017 * normal mono mic.
2018 */
2019/*  DMIC_CONTROL? Init value = 0x0001 */
2020	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2021	{0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2022	{ }
2023};
2024
2025static struct hda_input_mux alc888_2_capture_sources[2] = {
2026	/* Front mic only available on one ADC */
2027	{
2028		.num_items = 4,
2029		.items = {
2030			{ "Mic", 0x0 },
2031			{ "Line", 0x2 },
2032			{ "CD", 0x4 },
2033			{ "Front Mic", 0xb },
2034		},
2035	},
2036	{
2037		.num_items = 3,
2038		.items = {
2039			{ "Mic", 0x0 },
2040			{ "Line", 0x2 },
2041			{ "CD", 0x4 },
2042		},
2043	}
2044};
2045
2046static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2047	/* Interal mic only available on one ADC */
2048	{
2049		.num_items = 5,
2050		.items = {
2051			{ "Ext Mic", 0x0 },
2052			{ "Line In", 0x2 },
2053			{ "CD", 0x4 },
2054			{ "Input Mix", 0xa },
2055			{ "Int Mic", 0xb },
2056		},
2057	},
2058	{
2059		.num_items = 4,
2060		.items = {
2061			{ "Ext Mic", 0x0 },
2062			{ "Line In", 0x2 },
2063			{ "CD", 0x4 },
2064			{ "Input Mix", 0xa },
2065		},
2066	}
2067};
2068
2069static struct hda_input_mux alc889_capture_sources[3] = {
2070	/* Digital mic only available on first "ADC" */
2071	{
2072		.num_items = 5,
2073		.items = {
2074			{ "Mic", 0x0 },
2075			{ "Line", 0x2 },
2076			{ "CD", 0x4 },
2077			{ "Front Mic", 0xb },
2078			{ "Input Mix", 0xa },
2079		},
2080	},
2081	{
2082		.num_items = 4,
2083		.items = {
2084			{ "Mic", 0x0 },
2085			{ "Line", 0x2 },
2086			{ "CD", 0x4 },
2087			{ "Input Mix", 0xa },
2088		},
2089	},
2090	{
2091		.num_items = 4,
2092		.items = {
2093			{ "Mic", 0x0 },
2094			{ "Line", 0x2 },
2095			{ "CD", 0x4 },
2096			{ "Input Mix", 0xa },
2097		},
2098	}
2099};
2100
2101static struct snd_kcontrol_new alc888_base_mixer[] = {
2102	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2103	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2104	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2105	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2106	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2107		HDA_OUTPUT),
2108	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2109	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2110	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2111	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2112	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2113	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2114	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2115	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2116	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2117	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2118	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2119	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2120	{ } /* end */
2121};
2122
2123static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2124	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2125	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2126	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2127	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2128	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2129		HDA_OUTPUT),
2130	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2131	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2132	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2133	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2134	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2135	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2136	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2137	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2138	{ } /* end */
2139};
2140
2141
2142static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2143{
2144	struct alc_spec *spec = codec->spec;
2145
2146	spec->autocfg.hp_pins[0] = 0x15;
2147	spec->autocfg.speaker_pins[0] = 0x14;
2148	spec->autocfg.speaker_pins[1] = 0x16;
2149	spec->autocfg.speaker_pins[2] = 0x17;
2150}
2151
2152static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2153{
2154	struct alc_spec *spec = codec->spec;
2155
2156	spec->autocfg.hp_pins[0] = 0x15;
2157	spec->autocfg.speaker_pins[0] = 0x14;
2158	spec->autocfg.speaker_pins[1] = 0x16;
2159	spec->autocfg.speaker_pins[2] = 0x17;
2160}
2161
2162static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2163{
2164	struct alc_spec *spec = codec->spec;
2165
2166	spec->autocfg.hp_pins[0] = 0x15;
2167	spec->autocfg.speaker_pins[0] = 0x14;
2168	spec->autocfg.speaker_pins[1] = 0x16;
2169	spec->autocfg.speaker_pins[2] = 0x1b;
2170}
2171
2172/*
2173 * ALC880 3-stack model
2174 *
2175 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2176 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2177 *                 F-Mic = 0x1b, HP = 0x19
2178 */
2179
2180static hda_nid_t alc880_dac_nids[4] = {
2181	/* front, rear, clfe, rear_surr */
2182	0x02, 0x05, 0x04, 0x03
2183};
2184
2185static hda_nid_t alc880_adc_nids[3] = {
2186	/* ADC0-2 */
2187	0x07, 0x08, 0x09,
2188};
2189
2190/* The datasheet says the node 0x07 is connected from inputs,
2191 * but it shows zero connection in the real implementation on some devices.
2192 * Note: this is a 915GAV bug, fixed on 915GLV
2193 */
2194static hda_nid_t alc880_adc_nids_alt[2] = {
2195	/* ADC1-2 */
2196	0x08, 0x09,
2197};
2198
2199#define ALC880_DIGOUT_NID	0x06
2200#define ALC880_DIGIN_NID	0x0a
2201
2202static struct hda_input_mux alc880_capture_source = {
2203	.num_items = 4,
2204	.items = {
2205		{ "Mic", 0x0 },
2206		{ "Front Mic", 0x3 },
2207		{ "Line", 0x2 },
2208		{ "CD", 0x4 },
2209	},
2210};
2211
2212/* channel source setting (2/6 channel selection for 3-stack) */
2213/* 2ch mode */
2214static struct hda_verb alc880_threestack_ch2_init[] = {
2215	/* set line-in to input, mute it */
2216	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2217	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2218	/* set mic-in to input vref 80%, mute it */
2219	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2220	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2221	{ } /* end */
2222};
2223
2224/* 6ch mode */
2225static struct hda_verb alc880_threestack_ch6_init[] = {
2226	/* set line-in to output, unmute it */
2227	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2228	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2229	/* set mic-in to output, unmute it */
2230	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2231	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2232	{ } /* end */
2233};
2234
2235static struct hda_channel_mode alc880_threestack_modes[2] = {
2236	{ 2, alc880_threestack_ch2_init },
2237	{ 6, alc880_threestack_ch6_init },
2238};
2239
2240static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2241	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2242	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2243	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2244	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2245	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2246	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2247	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2248	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2249	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2250	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2251	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2252	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2253	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2254	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2255	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2256	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2257	HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2258	{
2259		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2260		.name = "Channel Mode",
2261		.info = alc_ch_mode_info,
2262		.get = alc_ch_mode_get,
2263		.put = alc_ch_mode_put,
2264	},
2265	{ } /* end */
2266};
2267
2268/* capture mixer elements */
2269static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2270			    struct snd_ctl_elem_info *uinfo)
2271{
2272	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2273	struct alc_spec *spec = codec->spec;
2274	int err;
2275
2276	mutex_lock(&codec->control_mutex);
2277	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2278						      HDA_INPUT);
2279	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2280	mutex_unlock(&codec->control_mutex);
2281	return err;
2282}
2283
2284static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2285			   unsigned int size, unsigned int __user *tlv)
2286{
2287	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2288	struct alc_spec *spec = codec->spec;
2289	int err;
2290
2291	mutex_lock(&codec->control_mutex);
2292	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2293						      HDA_INPUT);
2294	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2295	mutex_unlock(&codec->control_mutex);
2296	return err;
2297}
2298
2299typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2300			     struct snd_ctl_elem_value *ucontrol);
2301
2302static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2303				 struct snd_ctl_elem_value *ucontrol,
2304				 getput_call_t func)
2305{
2306	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2307	struct alc_spec *spec = codec->spec;
2308	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2309	int err;
2310
2311	mutex_lock(&codec->control_mutex);
2312	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2313						      3, 0, HDA_INPUT);
2314	err = func(kcontrol, ucontrol);
2315	mutex_unlock(&codec->control_mutex);
2316	return err;
2317}
2318
2319static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2320			   struct snd_ctl_elem_value *ucontrol)
2321{
2322	return alc_cap_getput_caller(kcontrol, ucontrol,
2323				     snd_hda_mixer_amp_volume_get);
2324}
2325
2326static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2327			   struct snd_ctl_elem_value *ucontrol)
2328{
2329	return alc_cap_getput_caller(kcontrol, ucontrol,
2330				     snd_hda_mixer_amp_volume_put);
2331}
2332
2333/* capture mixer elements */
2334#define alc_cap_sw_info		snd_ctl_boolean_stereo_info
2335
2336static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2337			  struct snd_ctl_elem_value *ucontrol)
2338{
2339	return alc_cap_getput_caller(kcontrol, ucontrol,
2340				     snd_hda_mixer_amp_switch_get);
2341}
2342
2343static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2344			  struct snd_ctl_elem_value *ucontrol)
2345{
2346	return alc_cap_getput_caller(kcontrol, ucontrol,
2347				     snd_hda_mixer_amp_switch_put);
2348}
2349
2350#define _DEFINE_CAPMIX(num) \
2351	{ \
2352		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2353		.name = "Capture Switch", \
2354		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2355		.count = num, \
2356		.info = alc_cap_sw_info, \
2357		.get = alc_cap_sw_get, \
2358		.put = alc_cap_sw_put, \
2359	}, \
2360	{ \
2361		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2362		.name = "Capture Volume", \
2363		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2364			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2365			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2366		.count = num, \
2367		.info = alc_cap_vol_info, \
2368		.get = alc_cap_vol_get, \
2369		.put = alc_cap_vol_put, \
2370		.tlv = { .c = alc_cap_vol_tlv }, \
2371	}
2372
2373#define _DEFINE_CAPSRC(num) \
2374	{ \
2375		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2376		/* .name = "Capture Source", */ \
2377		.name = "Input Source", \
2378		.count = num, \
2379		.info = alc_mux_enum_info, \
2380		.get = alc_mux_enum_get, \
2381		.put = alc_mux_enum_put, \
2382	}
2383
2384#define DEFINE_CAPMIX(num) \
2385static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2386	_DEFINE_CAPMIX(num),				      \
2387	_DEFINE_CAPSRC(num),				      \
2388	{ } /* end */					      \
2389}
2390
2391#define DEFINE_CAPMIX_NOSRC(num) \
2392static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2393	_DEFINE_CAPMIX(num),					    \
2394	{ } /* end */						    \
2395}
2396
2397/* up to three ADCs */
2398DEFINE_CAPMIX(1);
2399DEFINE_CAPMIX(2);
2400DEFINE_CAPMIX(3);
2401DEFINE_CAPMIX_NOSRC(1);
2402DEFINE_CAPMIX_NOSRC(2);
2403DEFINE_CAPMIX_NOSRC(3);
2404
2405/*
2406 * ALC880 5-stack model
2407 *
2408 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2409 *      Side = 0x02 (0xd)
2410 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2411 *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2412 */
2413
2414/* additional mixers to alc880_three_stack_mixer */
2415static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2416	HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2417	HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2418	{ } /* end */
2419};
2420
2421/* channel source setting (6/8 channel selection for 5-stack) */
2422/* 6ch mode */
2423static struct hda_verb alc880_fivestack_ch6_init[] = {
2424	/* set line-in to input, mute it */
2425	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2426	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2427	{ } /* end */
2428};
2429
2430/* 8ch mode */
2431static struct hda_verb alc880_fivestack_ch8_init[] = {
2432	/* set line-in to output, unmute it */
2433	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2434	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2435	{ } /* end */
2436};
2437
2438static struct hda_channel_mode alc880_fivestack_modes[2] = {
2439	{ 6, alc880_fivestack_ch6_init },
2440	{ 8, alc880_fivestack_ch8_init },
2441};
2442
2443
2444/*
2445 * ALC880 6-stack model
2446 *
2447 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2448 *      Side = 0x05 (0x0f)
2449 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2450 *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2451 */
2452
2453static hda_nid_t alc880_6st_dac_nids[4] = {
2454	/* front, rear, clfe, rear_surr */
2455	0x02, 0x03, 0x04, 0x05
2456};
2457
2458static struct hda_input_mux alc880_6stack_capture_source = {
2459	.num_items = 4,
2460	.items = {
2461		{ "Mic", 0x0 },
2462		{ "Front Mic", 0x1 },
2463		{ "Line", 0x2 },
2464		{ "CD", 0x4 },
2465	},
2466};
2467
2468/* fixed 8-channels */
2469static struct hda_channel_mode alc880_sixstack_modes[1] = {
2470	{ 8, NULL },
2471};
2472
2473static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2474	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2475	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2476	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2477	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2478	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2479	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2480	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2481	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2482	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2483	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2484	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2485	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2486	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2487	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2488	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2489	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2490	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2491	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2492	{
2493		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2494		.name = "Channel Mode",
2495		.info = alc_ch_mode_info,
2496		.get = alc_ch_mode_get,
2497		.put = alc_ch_mode_put,
2498	},
2499	{ } /* end */
2500};
2501
2502
2503/*
2504 * ALC880 W810 model
2505 *
2506 * W810 has rear IO for:
2507 * Front (DAC 02)
2508 * Surround (DAC 03)
2509 * Center/LFE (DAC 04)
2510 * Digital out (06)
2511 *
2512 * The system also has a pair of internal speakers, and a headphone jack.
2513 * These are both connected to Line2 on the codec, hence to DAC 02.
2514 *
2515 * There is a variable resistor to control the speaker or headphone
2516 * volume. This is a hardware-only device without a software API.
2517 *
2518 * Plugging headphones in will disable the internal speakers. This is
2519 * implemented in hardware, not via the driver using jack sense. In
2520 * a similar fashion, plugging into the rear socket marked "front" will
2521 * disable both the speakers and headphones.
2522 *
2523 * For input, there's a microphone jack, and an "audio in" jack.
2524 * These may not do anything useful with this driver yet, because I
2525 * haven't setup any initialization verbs for these yet...
2526 */
2527
2528static hda_nid_t alc880_w810_dac_nids[3] = {
2529	/* front, rear/surround, clfe */
2530	0x02, 0x03, 0x04
2531};
2532
2533/* fixed 6 channels */
2534static struct hda_channel_mode alc880_w810_modes[1] = {
2535	{ 6, NULL }
2536};
2537
2538/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2539static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2540	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2541	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2542	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2543	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2544	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2545	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2546	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2547	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2548	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2549	{ } /* end */
2550};
2551
2552
2553/*
2554 * Z710V model
2555 *
2556 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2557 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2558 *                 Line = 0x1a
2559 */
2560
2561static hda_nid_t alc880_z71v_dac_nids[1] = {
2562	0x02
2563};
2564#define ALC880_Z71V_HP_DAC	0x03
2565
2566/* fixed 2 channels */
2567static struct hda_channel_mode alc880_2_jack_modes[1] = {
2568	{ 2, NULL }
2569};
2570
2571static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2572	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2573	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2574	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2575	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2576	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2577	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2578	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2579	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2580	{ } /* end */
2581};
2582
2583
2584/*
2585 * ALC880 F1734 model
2586 *
2587 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2588 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2589 */
2590
2591static hda_nid_t alc880_f1734_dac_nids[1] = {
2592	0x03
2593};
2594#define ALC880_F1734_HP_DAC	0x02
2595
2596static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2597	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2598	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2599	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2600	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2601	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2602	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2603	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2604	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2605	{ } /* end */
2606};
2607
2608static struct hda_input_mux alc880_f1734_capture_source = {
2609	.num_items = 2,
2610	.items = {
2611		{ "Mic", 0x1 },
2612		{ "CD", 0x4 },
2613	},
2614};
2615
2616
2617/*
2618 * ALC880 ASUS model
2619 *
2620 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2621 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2622 *  Mic = 0x18, Line = 0x1a
2623 */
2624
2625#define alc880_asus_dac_nids	alc880_w810_dac_nids	/* identical with w810 */
2626#define alc880_asus_modes	alc880_threestack_modes	/* 2/6 channel mode */
2627
2628static struct snd_kcontrol_new alc880_asus_mixer[] = {
2629	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2630	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2631	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2632	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2633	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2634	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2635	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2636	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2637	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2638	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2639	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2640	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2641	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2642	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2643	{
2644		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2645		.name = "Channel Mode",
2646		.info = alc_ch_mode_info,
2647		.get = alc_ch_mode_get,
2648		.put = alc_ch_mode_put,
2649	},
2650	{ } /* end */
2651};
2652
2653/*
2654 * ALC880 ASUS W1V model
2655 *
2656 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2657 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2658 *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2659 */
2660
2661/* additional mixers to alc880_asus_mixer */
2662static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2663	HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2664	HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2665	{ } /* end */
2666};
2667
2668/* TCL S700 */
2669static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2670	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2671	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2672	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2673	HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2674	HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2675	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2676	HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2677	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2678	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2679	{ } /* end */
2680};
2681
2682/* Uniwill */
2683static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2684	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2685	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2686	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2687	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2688	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2689	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2690	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2691	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2692	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2693	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2694	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2695	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2696	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2697	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2698	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2699	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2700	{
2701		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2702		.name = "Channel Mode",
2703		.info = alc_ch_mode_info,
2704		.get = alc_ch_mode_get,
2705		.put = alc_ch_mode_put,
2706	},
2707	{ } /* end */
2708};
2709
2710static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2711	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2712	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2713	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2714	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2715	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2716	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2717	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2718	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2719	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2720	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2721	{ } /* end */
2722};
2723
2724static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2725	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2726	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2727	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2728	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2729	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2730	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2731	{ } /* end */
2732};
2733
2734/*
2735 * virtual master controls
2736 */
2737
2738/*
2739 * slave controls for virtual master
2740 */
2741static const char *alc_slave_vols[] = {
2742	"Front Playback Volume",
2743	"Surround Playback Volume",
2744	"Center Playback Volume",
2745	"LFE Playback Volume",
2746	"Side Playback Volume",
2747	"Headphone Playback Volume",
2748	"Speaker Playback Volume",
2749	"Mono Playback Volume",
2750	"Line-Out Playback Volume",
2751	"PCM Playback Volume",
2752	NULL,
2753};
2754
2755static const char *alc_slave_sws[] = {
2756	"Front Playback Switch",
2757	"Surround Playback Switch",
2758	"Center Playback Switch",
2759	"LFE Playback Switch",
2760	"Side Playback Switch",
2761	"Headphone Playback Switch",
2762	"Speaker Playback Switch",
2763	"Mono Playback Switch",
2764	"IEC958 Playback Switch",
2765	"Line-Out Playback Switch",
2766	"PCM Playback Switch",
2767	NULL,
2768};
2769
2770/*
2771 * build control elements
2772 */
2773
2774#define NID_MAPPING		(-1)
2775
2776#define SUBDEV_SPEAKER_		(0 << 6)
2777#define SUBDEV_HP_		(1 << 6)
2778#define SUBDEV_LINE_		(2 << 6)
2779#define SUBDEV_SPEAKER(x)	(SUBDEV_SPEAKER_ | ((x) & 0x3f))
2780#define SUBDEV_HP(x)		(SUBDEV_HP_ | ((x) & 0x3f))
2781#define SUBDEV_LINE(x)		(SUBDEV_LINE_ | ((x) & 0x3f))
2782
2783static void alc_free_kctls(struct hda_codec *codec);
2784
2785#ifdef CONFIG_SND_HDA_INPUT_BEEP
2786/* additional beep mixers; the actual parameters are overwritten at build */
2787static struct snd_kcontrol_new alc_beep_mixer[] = {
2788	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2789	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2790	{ } /* end */
2791};
2792#endif
2793
2794static int alc_build_controls(struct hda_codec *codec)
2795{
2796	struct alc_spec *spec = codec->spec;
2797	struct snd_kcontrol *kctl = NULL;
2798	struct snd_kcontrol_new *knew;
2799	int i, j, err;
2800	unsigned int u;
2801	hda_nid_t nid;
2802
2803	for (i = 0; i < spec->num_mixers; i++) {
2804		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2805		if (err < 0)
2806			return err;
2807	}
2808	if (spec->cap_mixer) {
2809		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2810		if (err < 0)
2811			return err;
2812	}
2813	if (spec->multiout.dig_out_nid) {
2814		err = snd_hda_create_spdif_out_ctls(codec,
2815						    spec->multiout.dig_out_nid);
2816		if (err < 0)
2817			return err;
2818		if (!spec->no_analog) {
2819			err = snd_hda_create_spdif_share_sw(codec,
2820							    &spec->multiout);
2821			if (err < 0)
2822				return err;
2823			spec->multiout.share_spdif = 1;
2824		}
2825	}
2826	if (spec->dig_in_nid) {
2827		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2828		if (err < 0)
2829			return err;
2830	}
2831
2832#ifdef CONFIG_SND_HDA_INPUT_BEEP
2833	/* create beep controls if needed */
2834	if (spec->beep_amp) {
2835		struct snd_kcontrol_new *knew;
2836		for (knew = alc_beep_mixer; knew->name; knew++) {
2837			struct snd_kcontrol *kctl;
2838			kctl = snd_ctl_new1(knew, codec);
2839			if (!kctl)
2840				return -ENOMEM;
2841			kctl->private_value = spec->beep_amp;
2842			err = snd_hda_ctl_add(codec, 0, kctl);
2843			if (err < 0)
2844				return err;
2845		}
2846	}
2847#endif
2848
2849	/* if we have no master control, let's create it */
2850	if (!spec->no_analog &&
2851	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2852		unsigned int vmaster_tlv[4];
2853		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2854					HDA_OUTPUT, vmaster_tlv);
2855		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2856					  vmaster_tlv, alc_slave_vols);
2857		if (err < 0)
2858			return err;
2859	}
2860	if (!spec->no_analog &&
2861	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2862		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2863					  NULL, alc_slave_sws);
2864		if (err < 0)
2865			return err;
2866	}
2867
2868	/* assign Capture Source enums to NID */
2869	if (spec->capsrc_nids || spec->adc_nids) {
2870		kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2871		if (!kctl)
2872			kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2873		for (i = 0; kctl && i < kctl->count; i++) {
2874			hda_nid_t *nids = spec->capsrc_nids;
2875			if (!nids)
2876				nids = spec->adc_nids;
2877			err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2878			if (err < 0)
2879				return err;
2880		}
2881	}
2882	if (spec->cap_mixer) {
2883		const char *kname = kctl ? kctl->id.name : NULL;
2884		for (knew = spec->cap_mixer; knew->name; knew++) {
2885			if (kname && strcmp(knew->name, kname) == 0)
2886				continue;
2887			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2888			for (i = 0; kctl && i < kctl->count; i++) {
2889				err = snd_hda_add_nid(codec, kctl, i,
2890						      spec->adc_nids[i]);
2891				if (err < 0)
2892					return err;
2893			}
2894		}
2895	}
2896
2897	/* other nid->control mapping */
2898	for (i = 0; i < spec->num_mixers; i++) {
2899		for (knew = spec->mixers[i]; knew->name; knew++) {
2900			if (knew->iface != NID_MAPPING)
2901				continue;
2902			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2903			if (kctl == NULL)
2904				continue;
2905			u = knew->subdevice;
2906			for (j = 0; j < 4; j++, u >>= 8) {
2907				nid = u & 0x3f;
2908				if (nid == 0)
2909					continue;
2910				switch (u & 0xc0) {
2911				case SUBDEV_SPEAKER_:
2912					nid = spec->autocfg.speaker_pins[nid];
2913					break;
2914				case SUBDEV_LINE_:
2915					nid = spec->autocfg.line_out_pins[nid];
2916					break;
2917				case SUBDEV_HP_:
2918					nid = spec->autocfg.hp_pins[nid];
2919					break;
2920				default:
2921					continue;
2922				}
2923				err = snd_hda_add_nid(codec, kctl, 0, nid);
2924				if (err < 0)
2925					return err;
2926			}
2927			u = knew->private_value;
2928			for (j = 0; j < 4; j++, u >>= 8) {
2929				nid = u & 0xff;
2930				if (nid == 0)
2931					continue;
2932				err = snd_hda_add_nid(codec, kctl, 0, nid);
2933				if (err < 0)
2934					return err;
2935			}
2936		}
2937	}
2938
2939	alc_free_kctls(codec); /* no longer needed */
2940
2941	return 0;
2942}
2943
2944
2945/*
2946 * initialize the codec volumes, etc
2947 */
2948
2949/*
2950 * generic initialization of ADC, input mixers and output mixers
2951 */
2952static struct hda_verb alc880_volume_init_verbs[] = {
2953	/*
2954	 * Unmute ADC0-2 and set the default input to mic-in
2955	 */
2956	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2957	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2958	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2959	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2960	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2961	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2962
2963	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2964	 * mixer widget
2965	 * Note: PASD motherboards uses the Line In 2 as the input for front
2966	 * panel mic (mic 2)
2967	 */
2968	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2969	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2970	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2971	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2972	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2973	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2974	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2975	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2976
2977	/*
2978	 * Set up output mixers (0x0c - 0x0f)
2979	 */
2980	/* set vol=0 to output mixers */
2981	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2982	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2983	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2984	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2985	/* set up input amps for analog loopback */
2986	/* Amp Indices: DAC = 0, mixer = 1 */
2987	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2988	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2989	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2990	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2991	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2992	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2993	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2994	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2995
2996	{ }
2997};
2998
2999/*
3000 * 3-stack pin configuration:
3001 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3002 */
3003static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3004	/*
3005	 * preset connection lists of input pins
3006	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3007	 */
3008	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3009	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3010	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3011
3012	/*
3013	 * Set pin mode and muting
3014	 */
3015	/* set front pin widgets 0x14 for output */
3016	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3017	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3018	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3019	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3020	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3021	/* Mic2 (as headphone out) for HP output */
3022	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3023	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3024	/* Line In pin widget for input */
3025	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3026	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3027	/* Line2 (as front mic) pin widget for input and vref at 80% */
3028	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3029	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3030	/* CD pin widget for input */
3031	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3032
3033	{ }
3034};
3035
3036/*
3037 * 5-stack pin configuration:
3038 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3039 * line-in/side = 0x1a, f-mic = 0x1b
3040 */
3041static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3042	/*
3043	 * preset connection lists of input pins
3044	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3045	 */
3046	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3047	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3048
3049	/*
3050	 * Set pin mode and muting
3051	 */
3052	/* set pin widgets 0x14-0x17 for output */
3053	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3054	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3055	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3056	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3057	/* unmute pins for output (no gain on this amp) */
3058	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3059	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3060	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3061	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3062
3063	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3064	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3065	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3066	/* Mic2 (as headphone out) for HP output */
3067	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3068	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3069	/* Line In pin widget for input */
3070	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3071	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3072	/* Line2 (as front mic) pin widget for input and vref at 80% */
3073	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3074	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3075	/* CD pin widget for input */
3076	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3077
3078	{ }
3079};
3080
3081/*
3082 * W810 pin configuration:
3083 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3084 */
3085static struct hda_verb alc880_pin_w810_init_verbs[] = {
3086	/* hphone/speaker input selector: front DAC */
3087	{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3088
3089	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3090	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3091	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3092	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3093	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3094	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3095
3096	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3097	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3098
3099	{ }
3100};
3101
3102/*
3103 * Z71V pin configuration:
3104 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3105 */
3106static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3107	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3108	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3109	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3110	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3111
3112	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3113	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3114	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3115	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3116
3117	{ }
3118};
3119
3120/*
3121 * 6-stack pin configuration:
3122 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3123 * f-mic = 0x19, line = 0x1a, HP = 0x1b
3124 */
3125static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3126	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3127
3128	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3129	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3130	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3131	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3132	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3133	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3134	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3135	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3136
3137	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3138	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3139	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3140	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3141	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3142	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3143	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3144	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3145	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3146
3147	{ }
3148};
3149
3150/*
3151 * Uniwill pin configuration:
3152 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3153 * line = 0x1a
3154 */
3155static struct hda_verb alc880_uniwill_init_verbs[] = {
3156	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3157
3158	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3159	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3160	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3161	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3162	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3163	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3164	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3165	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3166	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3167	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3168	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3169	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3170	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3171	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3172
3173	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3174	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3175	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3176	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3177	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3178	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3179	/* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3180	/* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3181	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3182
3183	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3184	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3185
3186	{ }
3187};
3188
3189/*
3190* Uniwill P53
3191* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3192 */
3193static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3194	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3195
3196	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3197	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3198	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3199	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3200	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3201	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3202	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3203	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3204	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3205	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3206	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3207	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3208
3209	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3210	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3211	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3212	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3213	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3214	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3215
3216	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3217	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3218
3219	{ }
3220};
3221
3222static struct hda_verb alc880_beep_init_verbs[] = {
3223	{ 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3224	{ }
3225};
3226
3227/* auto-toggle front mic */
3228static void alc880_uniwill_mic_automute(struct hda_codec *codec)
3229{
3230 	unsigned int present;
3231	unsigned char bits;
3232
3233	present = snd_hda_jack_detect(codec, 0x18);
3234	bits = present ? HDA_AMP_MUTE : 0;
3235	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3236}
3237
3238static void alc880_uniwill_setup(struct hda_codec *codec)
3239{
3240	struct alc_spec *spec = codec->spec;
3241
3242	spec->autocfg.hp_pins[0] = 0x14;
3243	spec->autocfg.speaker_pins[0] = 0x15;
3244	spec->autocfg.speaker_pins[0] = 0x16;
3245}
3246
3247static void alc880_uniwill_init_hook(struct hda_codec *codec)
3248{
3249	alc_automute_amp(codec);
3250	alc880_uniwill_mic_automute(codec);
3251}
3252
3253static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3254				       unsigned int res)
3255{
3256	/* Looks like the unsol event is incompatible with the standard
3257	 * definition.  4bit tag is placed at 28 bit!
3258	 */
3259	switch (res >> 28) {
3260	case ALC880_MIC_EVENT:
3261		alc880_uniwill_mic_automute(codec);
3262		break;
3263	default:
3264		alc_automute_amp_unsol_event(codec, res);
3265		break;
3266	}
3267}
3268
3269static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3270{
3271	struct alc_spec *spec = codec->spec;
3272
3273	spec->autocfg.hp_pins[0] = 0x14;
3274	spec->autocfg.speaker_pins[0] = 0x15;
3275}
3276
3277static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3278{
3279	unsigned int present;
3280
3281	present = snd_hda_codec_read(codec, 0x21, 0,
3282				     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3283	present &= HDA_AMP_VOLMASK;
3284	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3285				 HDA_AMP_VOLMASK, present);
3286	snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3287				 HDA_AMP_VOLMASK, present);
3288}
3289
3290static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3291					   unsigned int res)
3292{
3293	/* Looks like the unsol event is incompatible with the standard
3294	 * definition.  4bit tag is placed at 28 bit!
3295	 */
3296	if ((res >> 28) == ALC880_DCVOL_EVENT)
3297		alc880_uniwill_p53_dcvol_automute(codec);
3298	else
3299		alc_automute_amp_unsol_event(codec, res);
3300}
3301
3302/*
3303 * F1734 pin configuration:
3304 * HP = 0x14, speaker-out = 0x15, mic = 0x18
3305 */
3306static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3307	{0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3308	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3309	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3310	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3311	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3312
3313	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3314	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3315	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3316	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3317
3318	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3319	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3320	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3321	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3322	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3323	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3324	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3325	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3326	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3327
3328	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3329	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3330
3331	{ }
3332};
3333
3334/*
3335 * ASUS pin configuration:
3336 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3337 */
3338static struct hda_verb alc880_pin_asus_init_verbs[] = {
3339	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3340	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3341	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3342	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3343
3344	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3345	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3346	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3347	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3348	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3349	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3350	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3351	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3352
3353	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3354	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3355	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3356	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3357	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3358	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3359	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3360	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3361	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3362
3363	{ }
3364};
3365
3366/* Enable GPIO mask and set output */
3367#define alc880_gpio1_init_verbs	alc_gpio1_init_verbs
3368#define alc880_gpio2_init_verbs	alc_gpio2_init_verbs
3369#define alc880_gpio3_init_verbs	alc_gpio3_init_verbs
3370
3371/* Clevo m520g init */
3372static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3373	/* headphone output */
3374	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3375	/* line-out */
3376	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3377	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3378	/* Line-in */
3379	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3380	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3381	/* CD */
3382	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3383	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3384	/* Mic1 (rear panel) */
3385	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3386	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3387	/* Mic2 (front panel) */
3388	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3389	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3390	/* headphone */
3391	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3392	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3393        /* change to EAPD mode */
3394	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3395	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3396
3397	{ }
3398};
3399
3400static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3401	/* change to EAPD mode */
3402	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3403	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3404
3405	/* Headphone output */
3406	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3407	/* Front output*/
3408	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3409	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3410
3411	/* Line In pin widget for input */
3412	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3413	/* CD pin widget for input */
3414	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3415	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3416	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3417
3418	/* change to EAPD mode */
3419	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3420	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3421
3422	{ }
3423};
3424
3425/*
3426 * LG m1 express dual
3427 *
3428 * Pin assignment:
3429 *   Rear Line-In/Out (blue): 0x14
3430 *   Build-in Mic-In: 0x15
3431 *   Speaker-out: 0x17
3432 *   HP-Out (green): 0x1b
3433 *   Mic-In/Out (red): 0x19
3434 *   SPDIF-Out: 0x1e
3435 */
3436
3437/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3438static hda_nid_t alc880_lg_dac_nids[3] = {
3439	0x05, 0x02, 0x03
3440};
3441
3442/* seems analog CD is not working */
3443static struct hda_input_mux alc880_lg_capture_source = {
3444	.num_items = 3,
3445	.items = {
3446		{ "Mic", 0x1 },
3447		{ "Line", 0x5 },
3448		{ "Internal Mic", 0x6 },
3449	},
3450};
3451
3452/* 2,4,6 channel modes */
3453static struct hda_verb alc880_lg_ch2_init[] = {
3454	/* set line-in and mic-in to input */
3455	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3456	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3457	{ }
3458};
3459
3460static struct hda_verb alc880_lg_ch4_init[] = {
3461	/* set line-in to out and mic-in to input */
3462	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3463	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3464	{ }
3465};
3466
3467static struct hda_verb alc880_lg_ch6_init[] = {
3468	/* set line-in and mic-in to output */
3469	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3470	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3471	{ }
3472};
3473
3474static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3475	{ 2, alc880_lg_ch2_init },
3476	{ 4, alc880_lg_ch4_init },
3477	{ 6, alc880_lg_ch6_init },
3478};
3479
3480static struct snd_kcontrol_new alc880_lg_mixer[] = {
3481	HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3482	HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3483	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3484	HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3485	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3486	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3487	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3488	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3489	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3490	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3491	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3492	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3493	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3494	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3495	{
3496		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3497		.name = "Channel Mode",
3498		.info = alc_ch_mode_info,
3499		.get = alc_ch_mode_get,
3500		.put = alc_ch_mode_put,
3501	},
3502	{ } /* end */
3503};
3504
3505static struct hda_verb alc880_lg_init_verbs[] = {
3506	/* set capture source to mic-in */
3507	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3508	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3509	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3510	/* mute all amp mixer inputs */
3511	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3512	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3513	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3514	/* line-in to input */
3515	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3516	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3517	/* built-in mic */
3518	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3519	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3520	/* speaker-out */
3521	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3522	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3523	/* mic-in to input */
3524	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3525	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3526	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3527	/* HP-out */
3528	{0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3529	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3530	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3531	/* jack sense */
3532	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3533	{ }
3534};
3535
3536/* toggle speaker-output according to the hp-jack state */
3537static void alc880_lg_setup(struct hda_codec *codec)
3538{
3539	struct alc_spec *spec = codec->spec;
3540
3541	spec->autocfg.hp_pins[0] = 0x1b;
3542	spec->autocfg.speaker_pins[0] = 0x17;
3543}
3544
3545/*
3546 * LG LW20
3547 *
3548 * Pin assignment:
3549 *   Speaker-out: 0x14
3550 *   Mic-In: 0x18
3551 *   Built-in Mic-In: 0x19
3552 *   Line-In: 0x1b
3553 *   HP-Out: 0x1a
3554 *   SPDIF-Out: 0x1e
3555 */
3556
3557static struct hda_input_mux alc880_lg_lw_capture_source = {
3558	.num_items = 3,
3559	.items = {
3560		{ "Mic", 0x0 },
3561		{ "Internal Mic", 0x1 },
3562		{ "Line In", 0x2 },
3563	},
3564};
3565
3566#define alc880_lg_lw_modes alc880_threestack_modes
3567
3568static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3569	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3570	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3571	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3572	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3573	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3574	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3575	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3576	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3577	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3578	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3579	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3580	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3581	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3582	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3583	{
3584		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3585		.name = "Channel Mode",
3586		.info = alc_ch_mode_info,
3587		.get = alc_ch_mode_get,
3588		.put = alc_ch_mode_put,
3589	},
3590	{ } /* end */
3591};
3592
3593static struct hda_verb alc880_lg_lw_init_verbs[] = {
3594	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3595	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3596	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3597
3598	/* set capture source to mic-in */
3599	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3600	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3601	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3602	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3603	/* speaker-out */
3604	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3605	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3606	/* HP-out */
3607	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3608	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3609	/* mic-in to input */
3610	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3611	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3612	/* built-in mic */
3613	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3614	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3615	/* jack sense */
3616	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3617	{ }
3618};
3619
3620/* toggle speaker-output according to the hp-jack state */
3621static void alc880_lg_lw_setup(struct hda_codec *codec)
3622{
3623	struct alc_spec *spec = codec->spec;
3624
3625	spec->autocfg.hp_pins[0] = 0x1b;
3626	spec->autocfg.speaker_pins[0] = 0x14;
3627}
3628
3629static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3630	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3631	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3632	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3633	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3634	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3635	HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3636	{ } /* end */
3637};
3638
3639static struct hda_input_mux alc880_medion_rim_capture_source = {
3640	.num_items = 2,
3641	.items = {
3642		{ "Mic", 0x0 },
3643		{ "Internal Mic", 0x1 },
3644	},
3645};
3646
3647static struct hda_verb alc880_medion_rim_init_verbs[] = {
3648	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3649
3650	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3651	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3652
3653	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3654	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3655	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3656	/* Mic2 (as headphone out) for HP output */
3657	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3658	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3659	/* Internal Speaker */
3660	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3661	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3662
3663	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3664	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3665
3666	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3667	{ }
3668};
3669
3670/* toggle speaker-output according to the hp-jack state */
3671static void alc880_medion_rim_automute(struct hda_codec *codec)
3672{
3673	struct alc_spec *spec = codec->spec;
3674	alc_automute_amp(codec);
3675	/* toggle EAPD */
3676	if (spec->jack_present)
3677		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3678	else
3679		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3680}
3681
3682static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3683					  unsigned int res)
3684{
3685	/* Looks like the unsol event is incompatible with the standard
3686	 * definition.  4bit tag is placed at 28 bit!
3687	 */
3688	if ((res >> 28) == ALC880_HP_EVENT)
3689		alc880_medion_rim_automute(codec);
3690}
3691
3692static void alc880_medion_rim_setup(struct hda_codec *codec)
3693{
3694	struct alc_spec *spec = codec->spec;
3695
3696	spec->autocfg.hp_pins[0] = 0x14;
3697	spec->autocfg.speaker_pins[0] = 0x1b;
3698}
3699
3700#ifdef CONFIG_SND_HDA_POWER_SAVE
3701static struct hda_amp_list alc880_loopbacks[] = {
3702	{ 0x0b, HDA_INPUT, 0 },
3703	{ 0x0b, HDA_INPUT, 1 },
3704	{ 0x0b, HDA_INPUT, 2 },
3705	{ 0x0b, HDA_INPUT, 3 },
3706	{ 0x0b, HDA_INPUT, 4 },
3707	{ } /* end */
3708};
3709
3710static struct hda_amp_list alc880_lg_loopbacks[] = {
3711	{ 0x0b, HDA_INPUT, 1 },
3712	{ 0x0b, HDA_INPUT, 6 },
3713	{ 0x0b, HDA_INPUT, 7 },
3714	{ } /* end */
3715};
3716#endif
3717
3718/*
3719 * Common callbacks
3720 */
3721
3722static int alc_init(struct hda_codec *codec)
3723{
3724	struct alc_spec *spec = codec->spec;
3725	unsigned int i;
3726
3727	alc_fix_pll(codec);
3728	alc_auto_init_amp(codec, spec->init_amp);
3729
3730	for (i = 0; i < spec->num_init_verbs; i++)
3731		snd_hda_sequence_write(codec, spec->init_verbs[i]);
3732
3733	if (spec->init_hook)
3734		spec->init_hook(codec);
3735
3736	hda_call_check_power_status(codec, 0x01);
3737	return 0;
3738}
3739
3740static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3741{
3742	struct alc_spec *spec = codec->spec;
3743
3744	if (spec->unsol_event)
3745		spec->unsol_event(codec, res);
3746}
3747
3748#ifdef CONFIG_SND_HDA_POWER_SAVE
3749static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3750{
3751	struct alc_spec *spec = codec->spec;
3752	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3753}
3754#endif
3755
3756/*
3757 * Analog playback callbacks
3758 */
3759static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3760				    struct hda_codec *codec,
3761				    struct snd_pcm_substream *substream)
3762{
3763	struct alc_spec *spec = codec->spec;
3764	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3765					     hinfo);
3766}
3767
3768static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3769				       struct hda_codec *codec,
3770				       unsigned int stream_tag,
3771				       unsigned int format,
3772				       struct snd_pcm_substream *substream)
3773{
3774	struct alc_spec *spec = codec->spec;
3775	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3776						stream_tag, format, substream);
3777}
3778
3779static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3780				       struct hda_codec *codec,
3781				       struct snd_pcm_substream *substream)
3782{
3783	struct alc_spec *spec = codec->spec;
3784	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3785}
3786
3787/*
3788 * Digital out
3789 */
3790static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3791					struct hda_codec *codec,
3792					struct snd_pcm_substream *substream)
3793{
3794	struct alc_spec *spec = codec->spec;
3795	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3796}
3797
3798static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3799					   struct hda_codec *codec,
3800					   unsigned int stream_tag,
3801					   unsigned int format,
3802					   struct snd_pcm_substream *substream)
3803{
3804	struct alc_spec *spec = codec->spec;
3805	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3806					     stream_tag, format, substream);
3807}
3808
3809static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3810					   struct hda_codec *codec,
3811					   struct snd_pcm_substream *substream)
3812{
3813	struct alc_spec *spec = codec->spec;
3814	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3815}
3816
3817static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3818					 struct hda_codec *codec,
3819					 struct snd_pcm_substream *substream)
3820{
3821	struct alc_spec *spec = codec->spec;
3822	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3823}
3824
3825/*
3826 * Analog capture
3827 */
3828static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3829				      struct hda_codec *codec,
3830				      unsigned int stream_tag,
3831				      unsigned int format,
3832				      struct snd_pcm_substream *substream)
3833{
3834	struct alc_spec *spec = codec->spec;
3835
3836	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3837				   stream_tag, 0, format);
3838	return 0;
3839}
3840
3841static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3842				      struct hda_codec *codec,
3843				      struct snd_pcm_substream *substream)
3844{
3845	struct alc_spec *spec = codec->spec;
3846
3847	snd_hda_codec_cleanup_stream(codec,
3848				     spec->adc_nids[substream->number + 1]);
3849	return 0;
3850}
3851
3852/* analog capture with dynamic dual-adc changes */
3853static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3854				       struct hda_codec *codec,
3855				       unsigned int stream_tag,
3856				       unsigned int format,
3857				       struct snd_pcm_substream *substream)
3858{
3859	struct alc_spec *spec = codec->spec;
3860	spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3861	spec->cur_adc_stream_tag = stream_tag;
3862	spec->cur_adc_format = format;
3863	snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3864	return 0;
3865}
3866
3867static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3868				       struct hda_codec *codec,
3869				       struct snd_pcm_substream *substream)
3870{
3871	struct alc_spec *spec = codec->spec;
3872	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3873	spec->cur_adc = 0;
3874	return 0;
3875}
3876
3877static struct hda_pcm_stream dualmic_pcm_analog_capture = {
3878	.substreams = 1,
3879	.channels_min = 2,
3880	.channels_max = 2,
3881	.nid = 0, /* fill later */
3882	.ops = {
3883		.prepare = dualmic_capture_pcm_prepare,
3884		.cleanup = dualmic_capture_pcm_cleanup
3885	},
3886};
3887
3888/*
3889 */
3890static struct hda_pcm_stream alc880_pcm_analog_playback = {
3891	.substreams = 1,
3892	.channels_min = 2,
3893	.channels_max = 8,
3894	/* NID is set in alc_build_pcms */
3895	.ops = {
3896		.open = alc880_playback_pcm_open,
3897		.prepare = alc880_playback_pcm_prepare,
3898		.cleanup = alc880_playback_pcm_cleanup
3899	},
3900};
3901
3902static struct hda_pcm_stream alc880_pcm_analog_capture = {
3903	.substreams = 1,
3904	.channels_min = 2,
3905	.channels_max = 2,
3906	/* NID is set in alc_build_pcms */
3907};
3908
3909static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3910	.substreams = 1,
3911	.channels_min = 2,
3912	.channels_max = 2,
3913	/* NID is set in alc_build_pcms */
3914};
3915
3916static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3917	.substreams = 2, /* can be overridden */
3918	.channels_min = 2,
3919	.channels_max = 2,
3920	/* NID is set in alc_build_pcms */
3921	.ops = {
3922		.prepare = alc880_alt_capture_pcm_prepare,
3923		.cleanup = alc880_alt_capture_pcm_cleanup
3924	},
3925};
3926
3927static struct hda_pcm_stream alc880_pcm_digital_playback = {
3928	.substreams = 1,
3929	.channels_min = 2,
3930	.channels_max = 2,
3931	/* NID is set in alc_build_pcms */
3932	.ops = {
3933		.open = alc880_dig_playback_pcm_open,
3934		.close = alc880_dig_playback_pcm_close,
3935		.prepare = alc880_dig_playback_pcm_prepare,
3936		.cleanup = alc880_dig_playback_pcm_cleanup
3937	},
3938};
3939
3940static struct hda_pcm_stream alc880_pcm_digital_capture = {
3941	.substreams = 1,
3942	.channels_min = 2,
3943	.channels_max = 2,
3944	/* NID is set in alc_build_pcms */
3945};
3946
3947/* Used by alc_build_pcms to flag that a PCM has no playback stream */
3948static struct hda_pcm_stream alc_pcm_null_stream = {
3949	.substreams = 0,
3950	.channels_min = 0,
3951	.channels_max = 0,
3952};
3953
3954static int alc_build_pcms(struct hda_codec *codec)
3955{
3956	struct alc_spec *spec = codec->spec;
3957	struct hda_pcm *info = spec->pcm_rec;
3958	int i;
3959
3960	codec->num_pcms = 1;
3961	codec->pcm_info = info;
3962
3963	if (spec->no_analog)
3964		goto skip_analog;
3965
3966	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3967		 "%s Analog", codec->chip_name);
3968	info->name = spec->stream_name_analog;
3969
3970	if (spec->stream_analog_playback) {
3971		if (snd_BUG_ON(!spec->multiout.dac_nids))
3972			return -EINVAL;
3973		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3974		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3975	}
3976	if (spec->stream_analog_capture) {
3977		if (snd_BUG_ON(!spec->adc_nids))
3978			return -EINVAL;
3979		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3980		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3981	}
3982
3983	if (spec->channel_mode) {
3984		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3985		for (i = 0; i < spec->num_channel_mode; i++) {
3986			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3987				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3988			}
3989		}
3990	}
3991
3992 skip_analog:
3993	/* SPDIF for stream index #1 */
3994	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3995		snprintf(spec->stream_name_digital,
3996			 sizeof(spec->stream_name_digital),
3997			 "%s Digital", codec->chip_name);
3998		codec->num_pcms = 2;
3999	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4000		info = spec->pcm_rec + 1;
4001		info->name = spec->stream_name_digital;
4002		if (spec->dig_out_type)
4003			info->pcm_type = spec->dig_out_type;
4004		else
4005			info->pcm_type = HDA_PCM_TYPE_SPDIF;
4006		if (spec->multiout.dig_out_nid &&
4007		    spec->stream_digital_playback) {
4008			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4009			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4010		}
4011		if (spec->dig_in_nid &&
4012		    spec->stream_digital_capture) {
4013			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4014			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4015		}
4016		/* FIXME: do we need this for all Realtek codec models? */
4017		codec->spdif_status_reset = 1;
4018	}
4019
4020	if (spec->no_analog)
4021		return 0;
4022
4023	/* If the use of more than one ADC is requested for the current
4024	 * model, configure a second analog capture-only PCM.
4025	 */
4026	/* Additional Analaog capture for index #2 */
4027	if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4028	    (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4029		codec->num_pcms = 3;
4030		info = spec->pcm_rec + 2;
4031		info->name = spec->stream_name_analog;
4032		if (spec->alt_dac_nid) {
4033			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4034				*spec->stream_analog_alt_playback;
4035			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4036				spec->alt_dac_nid;
4037		} else {
4038			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4039				alc_pcm_null_stream;
4040			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4041		}
4042		if (spec->num_adc_nids > 1) {
4043			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4044				*spec->stream_analog_alt_capture;
4045			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4046				spec->adc_nids[1];
4047			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4048				spec->num_adc_nids - 1;
4049		} else {
4050			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4051				alc_pcm_null_stream;
4052			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4053		}
4054	}
4055
4056	return 0;
4057}
4058
4059static inline void alc_shutup(struct hda_codec *codec)
4060{
4061	snd_hda_shutup_pins(codec);
4062}
4063
4064static void alc_free_kctls(struct hda_codec *codec)
4065{
4066	struct alc_spec *spec = codec->spec;
4067
4068	if (spec->kctls.list) {
4069		struct snd_kcontrol_new *kctl = spec->kctls.list;
4070		int i;
4071		for (i = 0; i < spec->kctls.used; i++)
4072			kfree(kctl[i].name);
4073	}
4074	snd_array_free(&spec->kctls);
4075}
4076
4077static void alc_free(struct hda_codec *codec)
4078{
4079	struct alc_spec *spec = codec->spec;
4080
4081	if (!spec)
4082		return;
4083
4084	alc_shutup(codec);
4085	alc_free_kctls(codec);
4086	kfree(spec);
4087	snd_hda_detach_beep_device(codec);
4088}
4089
4090#ifdef CONFIG_SND_HDA_POWER_SAVE
4091static void alc_power_eapd(struct hda_codec *codec)
4092{
4093	/* We currently only handle front, HP */
4094	switch (codec->vendor_id) {
4095	case 0x10ec0260:
4096		set_eapd(codec, 0x0f, 0);
4097		set_eapd(codec, 0x10, 0);
4098		break;
4099	case 0x10ec0262:
4100	case 0x10ec0267:
4101	case 0x10ec0268:
4102	case 0x10ec0269:
4103	case 0x10ec0270:
4104	case 0x10ec0272:
4105	case 0x10ec0660:
4106	case 0x10ec0662:
4107	case 0x10ec0663:
4108	case 0x10ec0862:
4109	case 0x10ec0889:
4110		set_eapd(codec, 0x14, 0);
4111		set_eapd(codec, 0x15, 0);
4112		break;
4113	}
4114}
4115
4116static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4117{
4118	struct alc_spec *spec = codec->spec;
4119	alc_shutup(codec);
4120	if (spec && spec->power_hook)
4121		spec->power_hook(codec);
4122	return 0;
4123}
4124#endif
4125
4126#ifdef SND_HDA_NEEDS_RESUME
4127static int alc_resume(struct hda_codec *codec)
4128{
4129	codec->patch_ops.init(codec);
4130	snd_hda_codec_resume_amp(codec);
4131	snd_hda_codec_resume_cache(codec);
4132	hda_call_check_power_status(codec, 0x01);
4133	return 0;
4134}
4135#endif
4136
4137/*
4138 */
4139static struct hda_codec_ops alc_patch_ops = {
4140	.build_controls = alc_build_controls,
4141	.build_pcms = alc_build_pcms,
4142	.init = alc_init,
4143	.free = alc_free,
4144	.unsol_event = alc_unsol_event,
4145#ifdef SND_HDA_NEEDS_RESUME
4146	.resume = alc_resume,
4147#endif
4148#ifdef CONFIG_SND_HDA_POWER_SAVE
4149	.suspend = alc_suspend,
4150	.check_power_status = alc_check_power_status,
4151#endif
4152	.reboot_notify = alc_shutup,
4153};
4154
4155/* replace the codec chip_name with the given string */
4156static int alc_codec_rename(struct hda_codec *codec, const char *name)
4157{
4158	kfree(codec->chip_name);
4159	codec->chip_name = kstrdup(name, GFP_KERNEL);
4160	if (!codec->chip_name) {
4161		alc_free(codec);
4162		return -ENOMEM;
4163	}
4164	return 0;
4165}
4166
4167/*
4168 * Test configuration for debugging
4169 *
4170 * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4171 * enum controls.
4172 */
4173#ifdef CONFIG_SND_DEBUG
4174static hda_nid_t alc880_test_dac_nids[4] = {
4175	0x02, 0x03, 0x04, 0x05
4176};
4177
4178static struct hda_input_mux alc880_test_capture_source = {
4179	.num_items = 7,
4180	.items = {
4181		{ "In-1", 0x0 },
4182		{ "In-2", 0x1 },
4183		{ "In-3", 0x2 },
4184		{ "In-4", 0x3 },
4185		{ "CD", 0x4 },
4186		{ "Front", 0x5 },
4187		{ "Surround", 0x6 },
4188	},
4189};
4190
4191static struct hda_channel_mode alc880_test_modes[4] = {
4192	{ 2, NULL },
4193	{ 4, NULL },
4194	{ 6, NULL },
4195	{ 8, NULL },
4196};
4197
4198static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4199				 struct snd_ctl_elem_info *uinfo)
4200{
4201	static char *texts[] = {
4202		"N/A", "Line Out", "HP Out",
4203		"In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4204	};
4205	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4206	uinfo->count = 1;
4207	uinfo->value.enumerated.items = 8;
4208	if (uinfo->value.enumerated.item >= 8)
4209		uinfo->value.enumerated.item = 7;
4210	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4211	return 0;
4212}
4213
4214static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4215				struct snd_ctl_elem_value *ucontrol)
4216{
4217	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4218	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4219	unsigned int pin_ctl, item = 0;
4220
4221	pin_ctl = snd_hda_codec_read(codec, nid, 0,
4222				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4223	if (pin_ctl & AC_PINCTL_OUT_EN) {
4224		if (pin_ctl & AC_PINCTL_HP_EN)
4225			item = 2;
4226		else
4227			item = 1;
4228	} else if (pin_ctl & AC_PINCTL_IN_EN) {
4229		switch (pin_ctl & AC_PINCTL_VREFEN) {
4230		case AC_PINCTL_VREF_HIZ: item = 3; break;
4231		case AC_PINCTL_VREF_50:  item = 4; break;
4232		case AC_PINCTL_VREF_GRD: item = 5; break;
4233		case AC_PINCTL_VREF_80:  item = 6; break;
4234		case AC_PINCTL_VREF_100: item = 7; break;
4235		}
4236	}
4237	ucontrol->value.enumerated.item[0] = item;
4238	return 0;
4239}
4240
4241static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4242				struct snd_ctl_elem_value *ucontrol)
4243{
4244	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4245	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4246	static unsigned int ctls[] = {
4247		0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4248		AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4249		AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4250		AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4251		AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4252		AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4253	};
4254	unsigned int old_ctl, new_ctl;
4255
4256	old_ctl = snd_hda_codec_read(codec, nid, 0,
4257				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4258	new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4259	if (old_ctl != new_ctl) {
4260		int val;
4261		snd_hda_codec_write_cache(codec, nid, 0,
4262					  AC_VERB_SET_PIN_WIDGET_CONTROL,
4263					  new_ctl);
4264		val = ucontrol->value.enumerated.item[0] >= 3 ?
4265			HDA_AMP_MUTE : 0;
4266		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4267					 HDA_AMP_MUTE, val);
4268		return 1;
4269	}
4270	return 0;
4271}
4272
4273static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4274				 struct snd_ctl_elem_info *uinfo)
4275{
4276	static char *texts[] = {
4277		"Front", "Surround", "CLFE", "Side"
4278	};
4279	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4280	uinfo->count = 1;
4281	uinfo->value.enumerated.items = 4;
4282	if (uinfo->value.enumerated.item >= 4)
4283		uinfo->value.enumerated.item = 3;
4284	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4285	return 0;
4286}
4287
4288static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4289				struct snd_ctl_elem_value *ucontrol)
4290{
4291	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4292	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4293	unsigned int sel;
4294
4295	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4296	ucontrol->value.enumerated.item[0] = sel & 3;
4297	return 0;
4298}
4299
4300static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4301				struct snd_ctl_elem_value *ucontrol)
4302{
4303	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4304	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4305	unsigned int sel;
4306
4307	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4308	if (ucontrol->value.enumerated.item[0] != sel) {
4309		sel = ucontrol->value.enumerated.item[0] & 3;
4310		snd_hda_codec_write_cache(codec, nid, 0,
4311					  AC_VERB_SET_CONNECT_SEL, sel);
4312		return 1;
4313	}
4314	return 0;
4315}
4316
4317#define PIN_CTL_TEST(xname,nid) {			\
4318		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
4319			.name = xname,		       \
4320			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4321			.info = alc_test_pin_ctl_info, \
4322			.get = alc_test_pin_ctl_get,   \
4323			.put = alc_test_pin_ctl_put,   \
4324			.private_value = nid	       \
4325			}
4326
4327#define PIN_SRC_TEST(xname,nid) {			\
4328		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
4329			.name = xname,		       \
4330			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4331			.info = alc_test_pin_src_info, \
4332			.get = alc_test_pin_src_get,   \
4333			.put = alc_test_pin_src_put,   \
4334			.private_value = nid	       \
4335			}
4336
4337static struct snd_kcontrol_new alc880_test_mixer[] = {
4338	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4339	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4340	HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4341	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4342	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4343	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4344	HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4345	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4346	PIN_CTL_TEST("Front Pin Mode", 0x14),
4347	PIN_CTL_TEST("Surround Pin Mode", 0x15),
4348	PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4349	PIN_CTL_TEST("Side Pin Mode", 0x17),
4350	PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4351	PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4352	PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4353	PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4354	PIN_SRC_TEST("In-1 Pin Source", 0x18),
4355	PIN_SRC_TEST("In-2 Pin Source", 0x19),
4356	PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4357	PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4358	HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4359	HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4360	HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4361	HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4362	HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4363	HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4364	HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4365	HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4366	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4367	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4368	{
4369		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4370		.name = "Channel Mode",
4371		.info = alc_ch_mode_info,
4372		.get = alc_ch_mode_get,
4373		.put = alc_ch_mode_put,
4374	},
4375	{ } /* end */
4376};
4377
4378static struct hda_verb alc880_test_init_verbs[] = {
4379	/* Unmute inputs of 0x0c - 0x0f */
4380	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4381	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4382	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4383	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4384	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4385	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4386	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4387	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4388	/* Vol output for 0x0c-0x0f */
4389	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4390	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4391	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4392	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4393	/* Set output pins 0x14-0x17 */
4394	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4395	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4396	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4397	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4398	/* Unmute output pins 0x14-0x17 */
4399	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4400	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4401	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4402	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4403	/* Set input pins 0x18-0x1c */
4404	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4405	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4406	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4407	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4408	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4409	/* Mute input pins 0x18-0x1b */
4410	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4411	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4412	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4413	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4414	/* ADC set up */
4415	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4416	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4417	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4418	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4419	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4420	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4421	/* Analog input/passthru */
4422	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4423	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4424	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4425	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4426	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4427	{ }
4428};
4429#endif
4430
4431/*
4432 */
4433
4434static const char *alc880_models[ALC880_MODEL_LAST] = {
4435	[ALC880_3ST]		= "3stack",
4436	[ALC880_TCL_S700]	= "tcl",
4437	[ALC880_3ST_DIG]	= "3stack-digout",
4438	[ALC880_CLEVO]		= "clevo",
4439	[ALC880_5ST]		= "5stack",
4440	[ALC880_5ST_DIG]	= "5stack-digout",
4441	[ALC880_W810]		= "w810",
4442	[ALC880_Z71V]		= "z71v",
4443	[ALC880_6ST]		= "6stack",
4444	[ALC880_6ST_DIG]	= "6stack-digout",
4445	[ALC880_ASUS]		= "asus",
4446	[ALC880_ASUS_W1V]	= "asus-w1v",
4447	[ALC880_ASUS_DIG]	= "asus-dig",
4448	[ALC880_ASUS_DIG2]	= "asus-dig2",
4449	[ALC880_UNIWILL_DIG]	= "uniwill",
4450	[ALC880_UNIWILL_P53]	= "uniwill-p53",
4451	[ALC880_FUJITSU]	= "fujitsu",
4452	[ALC880_F1734]		= "F1734",
4453	[ALC880_LG]		= "lg",
4454	[ALC880_LG_LW]		= "lg-lw",
4455	[ALC880_MEDION_RIM]	= "medion",
4456#ifdef CONFIG_SND_DEBUG
4457	[ALC880_TEST]		= "test",
4458#endif
4459	[ALC880_AUTO]		= "auto",
4460};
4461
4462static struct snd_pci_quirk alc880_cfg_tbl[] = {
4463	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4464	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4465	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4466	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4467	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4468	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4469	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4470	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4471	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4472	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4473	SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4474	SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4475	SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4476	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4477	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4478	SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4479	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4480	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4481	/* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4482	SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4483	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4484	SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4485	SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4486	SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4487	SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4488	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4489	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4490	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4491	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4492	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4493	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4494	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4495	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4496	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4497	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4498	SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4499	SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4500	SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4501	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4502	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4503	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4504	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4505	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4506	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4507	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4508	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4509	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4510	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4511	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4512	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4513	SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4514	SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4515	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4516	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4517	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4518	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4519	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4520	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4521	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4522	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4523	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4524	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4525	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4526	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4527	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4528	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4529	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4530	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4531	/* default Intel */
4532	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4533	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4534	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4535	{}
4536};
4537
4538/*
4539 * ALC880 codec presets
4540 */
4541static struct alc_config_preset alc880_presets[] = {
4542	[ALC880_3ST] = {
4543		.mixers = { alc880_three_stack_mixer },
4544		.init_verbs = { alc880_volume_init_verbs,
4545				alc880_pin_3stack_init_verbs },
4546		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4547		.dac_nids = alc880_dac_nids,
4548		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4549		.channel_mode = alc880_threestack_modes,
4550		.need_dac_fix = 1,
4551		.input_mux = &alc880_capture_source,
4552	},
4553	[ALC880_3ST_DIG] = {
4554		.mixers = { alc880_three_stack_mixer },
4555		.init_verbs = { alc880_volume_init_verbs,
4556				alc880_pin_3stack_init_verbs },
4557		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4558		.dac_nids = alc880_dac_nids,
4559		.dig_out_nid = ALC880_DIGOUT_NID,
4560		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4561		.channel_mode = alc880_threestack_modes,
4562		.need_dac_fix = 1,
4563		.input_mux = &alc880_capture_source,
4564	},
4565	[ALC880_TCL_S700] = {
4566		.mixers = { alc880_tcl_s700_mixer },
4567		.init_verbs = { alc880_volume_init_verbs,
4568				alc880_pin_tcl_S700_init_verbs,
4569				alc880_gpio2_init_verbs },
4570		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4571		.dac_nids = alc880_dac_nids,
4572		.adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4573		.num_adc_nids = 1, /* single ADC */
4574		.hp_nid = 0x03,
4575		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4576		.channel_mode = alc880_2_jack_modes,
4577		.input_mux = &alc880_capture_source,
4578	},
4579	[ALC880_5ST] = {
4580		.mixers = { alc880_three_stack_mixer,
4581			    alc880_five_stack_mixer},
4582		.init_verbs = { alc880_volume_init_verbs,
4583				alc880_pin_5stack_init_verbs },
4584		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4585		.dac_nids = alc880_dac_nids,
4586		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4587		.channel_mode = alc880_fivestack_modes,
4588		.input_mux = &alc880_capture_source,
4589	},
4590	[ALC880_5ST_DIG] = {
4591		.mixers = { alc880_three_stack_mixer,
4592			    alc880_five_stack_mixer },
4593		.init_verbs = { alc880_volume_init_verbs,
4594				alc880_pin_5stack_init_verbs },
4595		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4596		.dac_nids = alc880_dac_nids,
4597		.dig_out_nid = ALC880_DIGOUT_NID,
4598		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4599		.channel_mode = alc880_fivestack_modes,
4600		.input_mux = &alc880_capture_source,
4601	},
4602	[ALC880_6ST] = {
4603		.mixers = { alc880_six_stack_mixer },
4604		.init_verbs = { alc880_volume_init_verbs,
4605				alc880_pin_6stack_init_verbs },
4606		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4607		.dac_nids = alc880_6st_dac_nids,
4608		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4609		.channel_mode = alc880_sixstack_modes,
4610		.input_mux = &alc880_6stack_capture_source,
4611	},
4612	[ALC880_6ST_DIG] = {
4613		.mixers = { alc880_six_stack_mixer },
4614		.init_verbs = { alc880_volume_init_verbs,
4615				alc880_pin_6stack_init_verbs },
4616		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4617		.dac_nids = alc880_6st_dac_nids,
4618		.dig_out_nid = ALC880_DIGOUT_NID,
4619		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4620		.channel_mode = alc880_sixstack_modes,
4621		.input_mux = &alc880_6stack_capture_source,
4622	},
4623	[ALC880_W810] = {
4624		.mixers = { alc880_w810_base_mixer },
4625		.init_verbs = { alc880_volume_init_verbs,
4626				alc880_pin_w810_init_verbs,
4627				alc880_gpio2_init_verbs },
4628		.num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4629		.dac_nids = alc880_w810_dac_nids,
4630		.dig_out_nid = ALC880_DIGOUT_NID,
4631		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4632		.channel_mode = alc880_w810_modes,
4633		.input_mux = &alc880_capture_source,
4634	},
4635	[ALC880_Z71V] = {
4636		.mixers = { alc880_z71v_mixer },
4637		.init_verbs = { alc880_volume_init_verbs,
4638				alc880_pin_z71v_init_verbs },
4639		.num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4640		.dac_nids = alc880_z71v_dac_nids,
4641		.dig_out_nid = ALC880_DIGOUT_NID,
4642		.hp_nid = 0x03,
4643		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4644		.channel_mode = alc880_2_jack_modes,
4645		.input_mux = &alc880_capture_source,
4646	},
4647	[ALC880_F1734] = {
4648		.mixers = { alc880_f1734_mixer },
4649		.init_verbs = { alc880_volume_init_verbs,
4650				alc880_pin_f1734_init_verbs },
4651		.num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4652		.dac_nids = alc880_f1734_dac_nids,
4653		.hp_nid = 0x02,
4654		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4655		.channel_mode = alc880_2_jack_modes,
4656		.input_mux = &alc880_f1734_capture_source,
4657		.unsol_event = alc880_uniwill_p53_unsol_event,
4658		.setup = alc880_uniwill_p53_setup,
4659		.init_hook = alc_automute_amp,
4660	},
4661	[ALC880_ASUS] = {
4662		.mixers = { alc880_asus_mixer },
4663		.init_verbs = { alc880_volume_init_verbs,
4664				alc880_pin_asus_init_verbs,
4665				alc880_gpio1_init_verbs },
4666		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4667		.dac_nids = alc880_asus_dac_nids,
4668		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4669		.channel_mode = alc880_asus_modes,
4670		.need_dac_fix = 1,
4671		.input_mux = &alc880_capture_source,
4672	},
4673	[ALC880_ASUS_DIG] = {
4674		.mixers = { alc880_asus_mixer },
4675		.init_verbs = { alc880_volume_init_verbs,
4676				alc880_pin_asus_init_verbs,
4677				alc880_gpio1_init_verbs },
4678		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4679		.dac_nids = alc880_asus_dac_nids,
4680		.dig_out_nid = ALC880_DIGOUT_NID,
4681		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4682		.channel_mode = alc880_asus_modes,
4683		.need_dac_fix = 1,
4684		.input_mux = &alc880_capture_source,
4685	},
4686	[ALC880_ASUS_DIG2] = {
4687		.mixers = { alc880_asus_mixer },
4688		.init_verbs = { alc880_volume_init_verbs,
4689				alc880_pin_asus_init_verbs,
4690				alc880_gpio2_init_verbs }, /* use GPIO2 */
4691		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4692		.dac_nids = alc880_asus_dac_nids,
4693		.dig_out_nid = ALC880_DIGOUT_NID,
4694		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4695		.channel_mode = alc880_asus_modes,
4696		.need_dac_fix = 1,
4697		.input_mux = &alc880_capture_source,
4698	},
4699	[ALC880_ASUS_W1V] = {
4700		.mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4701		.init_verbs = { alc880_volume_init_verbs,
4702				alc880_pin_asus_init_verbs,
4703				alc880_gpio1_init_verbs },
4704		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4705		.dac_nids = alc880_asus_dac_nids,
4706		.dig_out_nid = ALC880_DIGOUT_NID,
4707		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4708		.channel_mode = alc880_asus_modes,
4709		.need_dac_fix = 1,
4710		.input_mux = &alc880_capture_source,
4711	},
4712	[ALC880_UNIWILL_DIG] = {
4713		.mixers = { alc880_asus_mixer },
4714		.init_verbs = { alc880_volume_init_verbs,
4715				alc880_pin_asus_init_verbs },
4716		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4717		.dac_nids = alc880_asus_dac_nids,
4718		.dig_out_nid = ALC880_DIGOUT_NID,
4719		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4720		.channel_mode = alc880_asus_modes,
4721		.need_dac_fix = 1,
4722		.input_mux = &alc880_capture_source,
4723	},
4724	[ALC880_UNIWILL] = {
4725		.mixers = { alc880_uniwill_mixer },
4726		.init_verbs = { alc880_volume_init_verbs,
4727				alc880_uniwill_init_verbs },
4728		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4729		.dac_nids = alc880_asus_dac_nids,
4730		.dig_out_nid = ALC880_DIGOUT_NID,
4731		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4732		.channel_mode = alc880_threestack_modes,
4733		.need_dac_fix = 1,
4734		.input_mux = &alc880_capture_source,
4735		.unsol_event = alc880_uniwill_unsol_event,
4736		.setup = alc880_uniwill_setup,
4737		.init_hook = alc880_uniwill_init_hook,
4738	},
4739	[ALC880_UNIWILL_P53] = {
4740		.mixers = { alc880_uniwill_p53_mixer },
4741		.init_verbs = { alc880_volume_init_verbs,
4742				alc880_uniwill_p53_init_verbs },
4743		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4744		.dac_nids = alc880_asus_dac_nids,
4745		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4746		.channel_mode = alc880_threestack_modes,
4747		.input_mux = &alc880_capture_source,
4748		.unsol_event = alc880_uniwill_p53_unsol_event,
4749		.setup = alc880_uniwill_p53_setup,
4750		.init_hook = alc_automute_amp,
4751	},
4752	[ALC880_FUJITSU] = {
4753		.mixers = { alc880_fujitsu_mixer },
4754		.init_verbs = { alc880_volume_init_verbs,
4755				alc880_uniwill_p53_init_verbs,
4756	       			alc880_beep_init_verbs },
4757		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4758		.dac_nids = alc880_dac_nids,
4759		.dig_out_nid = ALC880_DIGOUT_NID,
4760		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4761		.channel_mode = alc880_2_jack_modes,
4762		.input_mux = &alc880_capture_source,
4763		.unsol_event = alc880_uniwill_p53_unsol_event,
4764		.setup = alc880_uniwill_p53_setup,
4765		.init_hook = alc_automute_amp,
4766	},
4767	[ALC880_CLEVO] = {
4768		.mixers = { alc880_three_stack_mixer },
4769		.init_verbs = { alc880_volume_init_verbs,
4770				alc880_pin_clevo_init_verbs },
4771		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4772		.dac_nids = alc880_dac_nids,
4773		.hp_nid = 0x03,
4774		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4775		.channel_mode = alc880_threestack_modes,
4776		.need_dac_fix = 1,
4777		.input_mux = &alc880_capture_source,
4778	},
4779	[ALC880_LG] = {
4780		.mixers = { alc880_lg_mixer },
4781		.init_verbs = { alc880_volume_init_verbs,
4782				alc880_lg_init_verbs },
4783		.num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4784		.dac_nids = alc880_lg_dac_nids,
4785		.dig_out_nid = ALC880_DIGOUT_NID,
4786		.num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4787		.channel_mode = alc880_lg_ch_modes,
4788		.need_dac_fix = 1,
4789		.input_mux = &alc880_lg_capture_source,
4790		.unsol_event = alc_automute_amp_unsol_event,
4791		.setup = alc880_lg_setup,
4792		.init_hook = alc_automute_amp,
4793#ifdef CONFIG_SND_HDA_POWER_SAVE
4794		.loopbacks = alc880_lg_loopbacks,
4795#endif
4796	},
4797	[ALC880_LG_LW] = {
4798		.mixers = { alc880_lg_lw_mixer },
4799		.init_verbs = { alc880_volume_init_verbs,
4800				alc880_lg_lw_init_verbs },
4801		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4802		.dac_nids = alc880_dac_nids,
4803		.dig_out_nid = ALC880_DIGOUT_NID,
4804		.num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4805		.channel_mode = alc880_lg_lw_modes,
4806		.input_mux = &alc880_lg_lw_capture_source,
4807		.unsol_event = alc_automute_amp_unsol_event,
4808		.setup = alc880_lg_lw_setup,
4809		.init_hook = alc_automute_amp,
4810	},
4811	[ALC880_MEDION_RIM] = {
4812		.mixers = { alc880_medion_rim_mixer },
4813		.init_verbs = { alc880_volume_init_verbs,
4814				alc880_medion_rim_init_verbs,
4815				alc_gpio2_init_verbs },
4816		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4817		.dac_nids = alc880_dac_nids,
4818		.dig_out_nid = ALC880_DIGOUT_NID,
4819		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4820		.channel_mode = alc880_2_jack_modes,
4821		.input_mux = &alc880_medion_rim_capture_source,
4822		.unsol_event = alc880_medion_rim_unsol_event,
4823		.setup = alc880_medion_rim_setup,
4824		.init_hook = alc880_medion_rim_automute,
4825	},
4826#ifdef CONFIG_SND_DEBUG
4827	[ALC880_TEST] = {
4828		.mixers = { alc880_test_mixer },
4829		.init_verbs = { alc880_test_init_verbs },
4830		.num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4831		.dac_nids = alc880_test_dac_nids,
4832		.dig_out_nid = ALC880_DIGOUT_NID,
4833		.num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4834		.channel_mode = alc880_test_modes,
4835		.input_mux = &alc880_test_capture_source,
4836	},
4837#endif
4838};
4839
4840/*
4841 * Automatic parse of I/O pins from the BIOS configuration
4842 */
4843
4844enum {
4845	ALC_CTL_WIDGET_VOL,
4846	ALC_CTL_WIDGET_MUTE,
4847	ALC_CTL_BIND_MUTE,
4848};
4849static struct snd_kcontrol_new alc880_control_templates[] = {
4850	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4851	HDA_CODEC_MUTE(NULL, 0, 0, 0),
4852	HDA_BIND_MUTE(NULL, 0, 0, 0),
4853};
4854
4855/* add dynamic controls */
4856static int add_control(struct alc_spec *spec, int type, const char *name,
4857		       int cidx, unsigned long val)
4858{
4859	struct snd_kcontrol_new *knew;
4860
4861	snd_array_init(&spec->kctls, sizeof(*knew), 32);
4862	knew = snd_array_new(&spec->kctls);
4863	if (!knew)
4864		return -ENOMEM;
4865	*knew = alc880_control_templates[type];
4866	knew->name = kstrdup(name, GFP_KERNEL);
4867	if (!knew->name)
4868		return -ENOMEM;
4869	knew->index = cidx;
4870	if (get_amp_nid_(val))
4871		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4872	knew->private_value = val;
4873	return 0;
4874}
4875
4876static int add_control_with_pfx(struct alc_spec *spec, int type,
4877				const char *pfx, const char *dir,
4878				const char *sfx, int cidx, unsigned long val)
4879{
4880	char name[32];
4881	snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4882	return add_control(spec, type, name, cidx, val);
4883}
4884
4885#define add_pb_vol_ctrl(spec, type, pfx, val)			\
4886	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
4887#define add_pb_sw_ctrl(spec, type, pfx, val)			\
4888	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
4889#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)			\
4890	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
4891#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)			\
4892	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
4893
4894#define alc880_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
4895#define alc880_fixed_pin_idx(nid)	((nid) - 0x14)
4896#define alc880_is_multi_pin(nid)	((nid) >= 0x18)
4897#define alc880_multi_pin_idx(nid)	((nid) - 0x18)
4898#define alc880_idx_to_dac(nid)		((nid) + 0x02)
4899#define alc880_dac_to_idx(nid)		((nid) - 0x02)
4900#define alc880_idx_to_mixer(nid)	((nid) + 0x0c)
4901#define alc880_idx_to_selector(nid)	((nid) + 0x10)
4902#define ALC880_PIN_CD_NID		0x1c
4903
4904/* fill in the dac_nids table from the parsed pin configuration */
4905static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4906				     const struct auto_pin_cfg *cfg)
4907{
4908	hda_nid_t nid;
4909	int assigned[4];
4910	int i, j;
4911
4912	memset(assigned, 0, sizeof(assigned));
4913	spec->multiout.dac_nids = spec->private_dac_nids;
4914
4915	/* check the pins hardwired to audio widget */
4916	for (i = 0; i < cfg->line_outs; i++) {
4917		nid = cfg->line_out_pins[i];
4918		if (alc880_is_fixed_pin(nid)) {
4919			int idx = alc880_fixed_pin_idx(nid);
4920			spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4921			assigned[idx] = 1;
4922		}
4923	}
4924	/* left pins can be connect to any audio widget */
4925	for (i = 0; i < cfg->line_outs; i++) {
4926		nid = cfg->line_out_pins[i];
4927		if (alc880_is_fixed_pin(nid))
4928			continue;
4929		/* search for an empty channel */
4930		for (j = 0; j < cfg->line_outs; j++) {
4931			if (!assigned[j]) {
4932				spec->multiout.dac_nids[i] =
4933					alc880_idx_to_dac(j);
4934				assigned[j] = 1;
4935				break;
4936			}
4937		}
4938	}
4939	spec->multiout.num_dacs = cfg->line_outs;
4940	return 0;
4941}
4942
4943/* add playback controls from the parsed DAC table */
4944static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4945					     const struct auto_pin_cfg *cfg)
4946{
4947	static const char *chname[4] = {
4948		"Front", "Surround", NULL /*CLFE*/, "Side"
4949	};
4950	hda_nid_t nid;
4951	int i, err;
4952
4953	for (i = 0; i < cfg->line_outs; i++) {
4954		if (!spec->multiout.dac_nids[i])
4955			continue;
4956		nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4957		if (i == 2) {
4958			/* Center/LFE */
4959			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4960					      "Center",
4961					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4962							      HDA_OUTPUT));
4963			if (err < 0)
4964				return err;
4965			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4966					      "LFE",
4967					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4968							      HDA_OUTPUT));
4969			if (err < 0)
4970				return err;
4971			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4972					     "Center",
4973					  HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4974							      HDA_INPUT));
4975			if (err < 0)
4976				return err;
4977			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4978					     "LFE",
4979					  HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4980							      HDA_INPUT));
4981			if (err < 0)
4982				return err;
4983		} else {
4984			const char *pfx;
4985			if (cfg->line_outs == 1 &&
4986			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4987				pfx = "Speaker";
4988			else
4989				pfx = chname[i];
4990			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4991					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4992							      HDA_OUTPUT));
4993			if (err < 0)
4994				return err;
4995			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4996					  HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4997							      HDA_INPUT));
4998			if (err < 0)
4999				return err;
5000		}
5001	}
5002	return 0;
5003}
5004
5005/* add playback controls for speaker and HP outputs */
5006static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5007					const char *pfx)
5008{
5009	hda_nid_t nid;
5010	int err;
5011
5012	if (!pin)
5013		return 0;
5014
5015	if (alc880_is_fixed_pin(pin)) {
5016		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5017		/* specify the DAC as the extra output */
5018		if (!spec->multiout.hp_nid)
5019			spec->multiout.hp_nid = nid;
5020		else
5021			spec->multiout.extra_out_nid[0] = nid;
5022		/* control HP volume/switch on the output mixer amp */
5023		nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5024		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5025				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5026		if (err < 0)
5027			return err;
5028		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5029				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5030		if (err < 0)
5031			return err;
5032	} else if (alc880_is_multi_pin(pin)) {
5033		/* set manual connection */
5034		/* we have only a switch on HP-out PIN */
5035		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5036				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5037		if (err < 0)
5038			return err;
5039	}
5040	return 0;
5041}
5042
5043/* create input playback/capture controls for the given pin */
5044static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5045			    const char *ctlname, int ctlidx,
5046			    int idx, hda_nid_t mix_nid)
5047{
5048	int err;
5049
5050	err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5051			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5052	if (err < 0)
5053		return err;
5054	err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5055			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5056	if (err < 0)
5057		return err;
5058	return 0;
5059}
5060
5061static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5062{
5063	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5064	return (pincap & AC_PINCAP_IN) != 0;
5065}
5066
5067/* create playback/capture controls for input pins */
5068static int alc_auto_create_input_ctls(struct hda_codec *codec,
5069				      const struct auto_pin_cfg *cfg,
5070				      hda_nid_t mixer,
5071				      hda_nid_t cap1, hda_nid_t cap2)
5072{
5073	struct alc_spec *spec = codec->spec;
5074	struct hda_input_mux *imux = &spec->private_imux[0];
5075	int i, err, idx, type, type_idx = 0;
5076
5077	for (i = 0; i < cfg->num_inputs; i++) {
5078		hda_nid_t pin;
5079		const char *label;
5080
5081		pin = cfg->inputs[i].pin;
5082		if (!alc_is_input_pin(codec, pin))
5083			continue;
5084
5085		type = cfg->inputs[i].type;
5086		if (i > 0 && type == cfg->inputs[i - 1].type)
5087			type_idx++;
5088		else
5089			type_idx = 0;
5090		label = hda_get_autocfg_input_label(codec, cfg, i);
5091		if (mixer) {
5092			idx = get_connection_index(codec, mixer, pin);
5093			if (idx >= 0) {
5094				err = new_analog_input(spec, pin,
5095						       label, type_idx,
5096						       idx, mixer);
5097				if (err < 0)
5098					return err;
5099			}
5100		}
5101
5102		if (!cap1)
5103			continue;
5104		idx = get_connection_index(codec, cap1, pin);
5105		if (idx < 0 && cap2)
5106			idx = get_connection_index(codec, cap2, pin);
5107		if (idx >= 0)
5108			snd_hda_add_imux_item(imux, label, idx, NULL);
5109	}
5110	return 0;
5111}
5112
5113static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5114						const struct auto_pin_cfg *cfg)
5115{
5116	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5117}
5118
5119static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5120			       unsigned int pin_type)
5121{
5122	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5123			    pin_type);
5124	/* unmute pin */
5125	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5126			    AMP_OUT_UNMUTE);
5127}
5128
5129static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5130					      hda_nid_t nid, int pin_type,
5131					      int dac_idx)
5132{
5133	alc_set_pin_output(codec, nid, pin_type);
5134	/* need the manual connection? */
5135	if (alc880_is_multi_pin(nid)) {
5136		struct alc_spec *spec = codec->spec;
5137		int idx = alc880_multi_pin_idx(nid);
5138		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5139				    AC_VERB_SET_CONNECT_SEL,
5140				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5141	}
5142}
5143
5144static int get_pin_type(int line_out_type)
5145{
5146	if (line_out_type == AUTO_PIN_HP_OUT)
5147		return PIN_HP;
5148	else
5149		return PIN_OUT;
5150}
5151
5152static void alc880_auto_init_multi_out(struct hda_codec *codec)
5153{
5154	struct alc_spec *spec = codec->spec;
5155	int i;
5156
5157	for (i = 0; i < spec->autocfg.line_outs; i++) {
5158		hda_nid_t nid = spec->autocfg.line_out_pins[i];
5159		int pin_type = get_pin_type(spec->autocfg.line_out_type);
5160		alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5161	}
5162}
5163
5164static void alc880_auto_init_extra_out(struct hda_codec *codec)
5165{
5166	struct alc_spec *spec = codec->spec;
5167	hda_nid_t pin;
5168
5169	pin = spec->autocfg.speaker_pins[0];
5170	if (pin) /* connect to front */
5171		alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5172	pin = spec->autocfg.hp_pins[0];
5173	if (pin) /* connect to front */
5174		alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5175}
5176
5177static void alc880_auto_init_analog_input(struct hda_codec *codec)
5178{
5179	struct alc_spec *spec = codec->spec;
5180	struct auto_pin_cfg *cfg = &spec->autocfg;
5181	int i;
5182
5183	for (i = 0; i < cfg->num_inputs; i++) {
5184		hda_nid_t nid = cfg->inputs[i].pin;
5185		if (alc_is_input_pin(codec, nid)) {
5186			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5187			if (nid != ALC880_PIN_CD_NID &&
5188			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5189				snd_hda_codec_write(codec, nid, 0,
5190						    AC_VERB_SET_AMP_GAIN_MUTE,
5191						    AMP_OUT_MUTE);
5192		}
5193	}
5194}
5195
5196static void alc880_auto_init_input_src(struct hda_codec *codec)
5197{
5198	struct alc_spec *spec = codec->spec;
5199	int c;
5200
5201	for (c = 0; c < spec->num_adc_nids; c++) {
5202		unsigned int mux_idx;
5203		const struct hda_input_mux *imux;
5204		mux_idx = c >= spec->num_mux_defs ? 0 : c;
5205		imux = &spec->input_mux[mux_idx];
5206		if (!imux->num_items && mux_idx > 0)
5207			imux = &spec->input_mux[0];
5208		if (imux)
5209			snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5210					    AC_VERB_SET_CONNECT_SEL,
5211					    imux->items[0].index);
5212	}
5213}
5214
5215/* parse the BIOS configuration and set up the alc_spec */
5216/* return 1 if successful, 0 if the proper config is not found,
5217 * or a negative error code
5218 */
5219static int alc880_parse_auto_config(struct hda_codec *codec)
5220{
5221	struct alc_spec *spec = codec->spec;
5222	int err;
5223	static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5224
5225	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5226					   alc880_ignore);
5227	if (err < 0)
5228		return err;
5229	if (!spec->autocfg.line_outs)
5230		return 0; /* can't find valid BIOS pin config */
5231
5232	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5233	if (err < 0)
5234		return err;
5235	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5236	if (err < 0)
5237		return err;
5238	err = alc880_auto_create_extra_out(spec,
5239					   spec->autocfg.speaker_pins[0],
5240					   "Speaker");
5241	if (err < 0)
5242		return err;
5243	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5244					   "Headphone");
5245	if (err < 0)
5246		return err;
5247	err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5248	if (err < 0)
5249		return err;
5250
5251	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5252
5253	alc_auto_parse_digital(codec);
5254
5255	if (spec->kctls.list)
5256		add_mixer(spec, spec->kctls.list);
5257
5258	add_verb(spec, alc880_volume_init_verbs);
5259
5260	spec->num_mux_defs = 1;
5261	spec->input_mux = &spec->private_imux[0];
5262
5263	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5264
5265	return 1;
5266}
5267
5268/* additional initialization for auto-configuration model */
5269static void alc880_auto_init(struct hda_codec *codec)
5270{
5271	struct alc_spec *spec = codec->spec;
5272	alc880_auto_init_multi_out(codec);
5273	alc880_auto_init_extra_out(codec);
5274	alc880_auto_init_analog_input(codec);
5275	alc880_auto_init_input_src(codec);
5276	alc_auto_init_digital(codec);
5277	if (spec->unsol_event)
5278		alc_inithook(codec);
5279}
5280
5281/* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5282 * one of two digital mic pins, e.g. on ALC272
5283 */
5284static void fixup_automic_adc(struct hda_codec *codec)
5285{
5286	struct alc_spec *spec = codec->spec;
5287	int i;
5288
5289	for (i = 0; i < spec->num_adc_nids; i++) {
5290		hda_nid_t cap = spec->capsrc_nids ?
5291			spec->capsrc_nids[i] : spec->adc_nids[i];
5292		int iidx, eidx;
5293
5294		iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5295		if (iidx < 0)
5296			continue;
5297		eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5298		if (eidx < 0)
5299			continue;
5300		spec->int_mic.mux_idx = iidx;
5301		spec->ext_mic.mux_idx = eidx;
5302		if (spec->capsrc_nids)
5303			spec->capsrc_nids += i;
5304		spec->adc_nids += i;
5305		spec->num_adc_nids = 1;
5306		return;
5307	}
5308	snd_printd(KERN_INFO "hda_codec: %s: "
5309		   "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5310		   codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5311	spec->auto_mic = 0; /* disable auto-mic to be sure */
5312}
5313
5314/* select or unmute the given capsrc route */
5315static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5316				    int idx)
5317{
5318	if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5319		snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5320					 HDA_AMP_MUTE, 0);
5321	} else {
5322		snd_hda_codec_write_cache(codec, cap, 0,
5323					  AC_VERB_SET_CONNECT_SEL, idx);
5324	}
5325}
5326
5327/* set the default connection to that pin */
5328static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5329{
5330	struct alc_spec *spec = codec->spec;
5331	int i;
5332
5333	for (i = 0; i < spec->num_adc_nids; i++) {
5334		hda_nid_t cap = spec->capsrc_nids ?
5335			spec->capsrc_nids[i] : spec->adc_nids[i];
5336		int idx;
5337
5338		idx = get_connection_index(codec, cap, pin);
5339		if (idx < 0)
5340			continue;
5341		select_or_unmute_capsrc(codec, cap, idx);
5342		return i; /* return the found index */
5343	}
5344	return -1; /* not found */
5345}
5346
5347/* choose the ADC/MUX containing the input pin and initialize the setup */
5348static void fixup_single_adc(struct hda_codec *codec)
5349{
5350	struct alc_spec *spec = codec->spec;
5351	struct auto_pin_cfg *cfg = &spec->autocfg;
5352	int i;
5353
5354	/* search for the input pin; there must be only one */
5355	if (cfg->num_inputs != 1)
5356		return;
5357	i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5358	if (i >= 0) {
5359		/* use only this ADC */
5360		if (spec->capsrc_nids)
5361			spec->capsrc_nids += i;
5362		spec->adc_nids += i;
5363		spec->num_adc_nids = 1;
5364	}
5365}
5366
5367/* initialize dual adcs */
5368static void fixup_dual_adc_switch(struct hda_codec *codec)
5369{
5370	struct alc_spec *spec = codec->spec;
5371	init_capsrc_for_pin(codec, spec->ext_mic.pin);
5372	init_capsrc_for_pin(codec, spec->int_mic.pin);
5373}
5374
5375static void set_capture_mixer(struct hda_codec *codec)
5376{
5377	struct alc_spec *spec = codec->spec;
5378	static struct snd_kcontrol_new *caps[2][3] = {
5379		{ alc_capture_mixer_nosrc1,
5380		  alc_capture_mixer_nosrc2,
5381		  alc_capture_mixer_nosrc3 },
5382		{ alc_capture_mixer1,
5383		  alc_capture_mixer2,
5384		  alc_capture_mixer3 },
5385	};
5386	if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5387		int mux = 0;
5388		int num_adcs = spec->num_adc_nids;
5389		if (spec->dual_adc_switch)
5390			fixup_dual_adc_switch(codec);
5391		else if (spec->auto_mic)
5392			fixup_automic_adc(codec);
5393		else if (spec->input_mux) {
5394			if (spec->input_mux->num_items > 1)
5395				mux = 1;
5396			else if (spec->input_mux->num_items == 1)
5397				fixup_single_adc(codec);
5398		}
5399		if (spec->dual_adc_switch)
5400			num_adcs = 1;
5401		spec->cap_mixer = caps[mux][num_adcs - 1];
5402	}
5403}
5404
5405/* fill adc_nids (and capsrc_nids) containing all active input pins */
5406static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5407				 int num_nids)
5408{
5409	struct alc_spec *spec = codec->spec;
5410	struct auto_pin_cfg *cfg = &spec->autocfg;
5411	int n;
5412	hda_nid_t fallback_adc = 0, fallback_cap = 0;
5413
5414	for (n = 0; n < num_nids; n++) {
5415		hda_nid_t adc, cap;
5416		hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5417		int nconns, i, j;
5418
5419		adc = nids[n];
5420		if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5421			continue;
5422		cap = adc;
5423		nconns = snd_hda_get_connections(codec, cap, conn,
5424						 ARRAY_SIZE(conn));
5425		if (nconns == 1) {
5426			cap = conn[0];
5427			nconns = snd_hda_get_connections(codec, cap, conn,
5428							 ARRAY_SIZE(conn));
5429		}
5430		if (nconns <= 0)
5431			continue;
5432		if (!fallback_adc) {
5433			fallback_adc = adc;
5434			fallback_cap = cap;
5435		}
5436		for (i = 0; i < cfg->num_inputs; i++) {
5437			hda_nid_t nid = cfg->inputs[i].pin;
5438			for (j = 0; j < nconns; j++) {
5439				if (conn[j] == nid)
5440					break;
5441			}
5442			if (j >= nconns)
5443				break;
5444		}
5445		if (i >= cfg->num_inputs) {
5446			int num_adcs = spec->num_adc_nids;
5447			spec->private_adc_nids[num_adcs] = adc;
5448			spec->private_capsrc_nids[num_adcs] = cap;
5449			spec->num_adc_nids++;
5450			spec->adc_nids = spec->private_adc_nids;
5451			if (adc != cap)
5452				spec->capsrc_nids = spec->private_capsrc_nids;
5453		}
5454	}
5455	if (!spec->num_adc_nids) {
5456		printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5457		       " using fallback 0x%x\n",
5458		       codec->chip_name, fallback_adc);
5459		spec->private_adc_nids[0] = fallback_adc;
5460		spec->adc_nids = spec->private_adc_nids;
5461		if (fallback_adc != fallback_cap) {
5462			spec->private_capsrc_nids[0] = fallback_cap;
5463			spec->capsrc_nids = spec->private_adc_nids;
5464		}
5465	}
5466}
5467
5468#ifdef CONFIG_SND_HDA_INPUT_BEEP
5469#define set_beep_amp(spec, nid, idx, dir) \
5470	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5471
5472static struct snd_pci_quirk beep_white_list[] = {
5473	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5474	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5475	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5476	{}
5477};
5478
5479static inline int has_cdefine_beep(struct hda_codec *codec)
5480{
5481	struct alc_spec *spec = codec->spec;
5482	const struct snd_pci_quirk *q;
5483	q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5484	if (q)
5485		return q->value;
5486	return spec->cdefine.enable_pcbeep;
5487}
5488#else
5489#define set_beep_amp(spec, nid, idx, dir) /* NOP */
5490#define has_cdefine_beep(codec)		0
5491#endif
5492
5493/*
5494 * OK, here we have finally the patch for ALC880
5495 */
5496
5497static int patch_alc880(struct hda_codec *codec)
5498{
5499	struct alc_spec *spec;
5500	int board_config;
5501	int err;
5502
5503	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5504	if (spec == NULL)
5505		return -ENOMEM;
5506
5507	codec->spec = spec;
5508
5509	board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5510						  alc880_models,
5511						  alc880_cfg_tbl);
5512	if (board_config < 0) {
5513		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5514		       codec->chip_name);
5515		board_config = ALC880_AUTO;
5516	}
5517
5518	if (board_config == ALC880_AUTO) {
5519		/* automatic parse from the BIOS config */
5520		err = alc880_parse_auto_config(codec);
5521		if (err < 0) {
5522			alc_free(codec);
5523			return err;
5524		} else if (!err) {
5525			printk(KERN_INFO
5526			       "hda_codec: Cannot set up configuration "
5527			       "from BIOS.  Using 3-stack mode...\n");
5528			board_config = ALC880_3ST;
5529		}
5530	}
5531
5532	err = snd_hda_attach_beep_device(codec, 0x1);
5533	if (err < 0) {
5534		alc_free(codec);
5535		return err;
5536	}
5537
5538	if (board_config != ALC880_AUTO)
5539		setup_preset(codec, &alc880_presets[board_config]);
5540
5541	spec->stream_analog_playback = &alc880_pcm_analog_playback;
5542	spec->stream_analog_capture = &alc880_pcm_analog_capture;
5543	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5544
5545	spec->stream_digital_playback = &alc880_pcm_digital_playback;
5546	spec->stream_digital_capture = &alc880_pcm_digital_capture;
5547
5548	if (!spec->adc_nids && spec->input_mux) {
5549		/* check whether NID 0x07 is valid */
5550		unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5551		/* get type */
5552		wcap = get_wcaps_type(wcap);
5553		if (wcap != AC_WID_AUD_IN) {
5554			spec->adc_nids = alc880_adc_nids_alt;
5555			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5556		} else {
5557			spec->adc_nids = alc880_adc_nids;
5558			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5559		}
5560	}
5561	set_capture_mixer(codec);
5562	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5563
5564	spec->vmaster_nid = 0x0c;
5565
5566	codec->patch_ops = alc_patch_ops;
5567	if (board_config == ALC880_AUTO)
5568		spec->init_hook = alc880_auto_init;
5569#ifdef CONFIG_SND_HDA_POWER_SAVE
5570	if (!spec->loopback.amplist)
5571		spec->loopback.amplist = alc880_loopbacks;
5572#endif
5573
5574	return 0;
5575}
5576
5577
5578/*
5579 * ALC260 support
5580 */
5581
5582static hda_nid_t alc260_dac_nids[1] = {
5583	/* front */
5584	0x02,
5585};
5586
5587static hda_nid_t alc260_adc_nids[1] = {
5588	/* ADC0 */
5589	0x04,
5590};
5591
5592static hda_nid_t alc260_adc_nids_alt[1] = {
5593	/* ADC1 */
5594	0x05,
5595};
5596
5597/* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5598 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5599 */
5600static hda_nid_t alc260_dual_adc_nids[2] = {
5601	/* ADC0, ADC1 */
5602	0x04, 0x05
5603};
5604
5605#define ALC260_DIGOUT_NID	0x03
5606#define ALC260_DIGIN_NID	0x06
5607
5608static struct hda_input_mux alc260_capture_source = {
5609	.num_items = 4,
5610	.items = {
5611		{ "Mic", 0x0 },
5612		{ "Front Mic", 0x1 },
5613		{ "Line", 0x2 },
5614		{ "CD", 0x4 },
5615	},
5616};
5617
5618/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5619 * headphone jack and the internal CD lines since these are the only pins at
5620 * which audio can appear.  For flexibility, also allow the option of
5621 * recording the mixer output on the second ADC (ADC0 doesn't have a
5622 * connection to the mixer output).
5623 */
5624static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5625	{
5626		.num_items = 3,
5627		.items = {
5628			{ "Mic/Line", 0x0 },
5629			{ "CD", 0x4 },
5630			{ "Headphone", 0x2 },
5631		},
5632	},
5633	{
5634		.num_items = 4,
5635		.items = {
5636			{ "Mic/Line", 0x0 },
5637			{ "CD", 0x4 },
5638			{ "Headphone", 0x2 },
5639			{ "Mixer", 0x5 },
5640		},
5641	},
5642
5643};
5644
5645/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5646 * the Fujitsu S702x, but jacks are marked differently.
5647 */
5648static struct hda_input_mux alc260_acer_capture_sources[2] = {
5649	{
5650		.num_items = 4,
5651		.items = {
5652			{ "Mic", 0x0 },
5653			{ "Line", 0x2 },
5654			{ "CD", 0x4 },
5655			{ "Headphone", 0x5 },
5656		},
5657	},
5658	{
5659		.num_items = 5,
5660		.items = {
5661			{ "Mic", 0x0 },
5662			{ "Line", 0x2 },
5663			{ "CD", 0x4 },
5664			{ "Headphone", 0x6 },
5665			{ "Mixer", 0x5 },
5666		},
5667	},
5668};
5669
5670/* Maxdata Favorit 100XS */
5671static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5672	{
5673		.num_items = 2,
5674		.items = {
5675			{ "Line/Mic", 0x0 },
5676			{ "CD", 0x4 },
5677		},
5678	},
5679	{
5680		.num_items = 3,
5681		.items = {
5682			{ "Line/Mic", 0x0 },
5683			{ "CD", 0x4 },
5684			{ "Mixer", 0x5 },
5685		},
5686	},
5687};
5688
5689/*
5690 * This is just place-holder, so there's something for alc_build_pcms to look
5691 * at when it calculates the maximum number of channels. ALC260 has no mixer
5692 * element which allows changing the channel mode, so the verb list is
5693 * never used.
5694 */
5695static struct hda_channel_mode alc260_modes[1] = {
5696	{ 2, NULL },
5697};
5698
5699
5700/* Mixer combinations
5701 *
5702 * basic: base_output + input + pc_beep + capture
5703 * HP: base_output + input + capture_alt
5704 * HP_3013: hp_3013 + input + capture
5705 * fujitsu: fujitsu + capture
5706 * acer: acer + capture
5707 */
5708
5709static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5710	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5711	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5712	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5713	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5714	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5715	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5716	{ } /* end */
5717};
5718
5719static struct snd_kcontrol_new alc260_input_mixer[] = {
5720	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5721	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5722	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5723	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5724	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5725	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5726	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5727	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5728	{ } /* end */
5729};
5730
5731/* update HP, line and mono out pins according to the master switch */
5732static void alc260_hp_master_update(struct hda_codec *codec,
5733				    hda_nid_t hp, hda_nid_t line,
5734				    hda_nid_t mono)
5735{
5736	struct alc_spec *spec = codec->spec;
5737	unsigned int val = spec->master_sw ? PIN_HP : 0;
5738	/* change HP and line-out pins */
5739	snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5740			    val);
5741	snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5742			    val);
5743	/* mono (speaker) depending on the HP jack sense */
5744	val = (val && !spec->jack_present) ? PIN_OUT : 0;
5745	snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5746			    val);
5747}
5748
5749static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5750				   struct snd_ctl_elem_value *ucontrol)
5751{
5752	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5753	struct alc_spec *spec = codec->spec;
5754	*ucontrol->value.integer.value = spec->master_sw;
5755	return 0;
5756}
5757
5758static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5759				   struct snd_ctl_elem_value *ucontrol)
5760{
5761	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5762	struct alc_spec *spec = codec->spec;
5763	int val = !!*ucontrol->value.integer.value;
5764	hda_nid_t hp, line, mono;
5765
5766	if (val == spec->master_sw)
5767		return 0;
5768	spec->master_sw = val;
5769	hp = (kcontrol->private_value >> 16) & 0xff;
5770	line = (kcontrol->private_value >> 8) & 0xff;
5771	mono = kcontrol->private_value & 0xff;
5772	alc260_hp_master_update(codec, hp, line, mono);
5773	return 1;
5774}
5775
5776static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5777	{
5778		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5779		.name = "Master Playback Switch",
5780		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5781		.info = snd_ctl_boolean_mono_info,
5782		.get = alc260_hp_master_sw_get,
5783		.put = alc260_hp_master_sw_put,
5784		.private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5785	},
5786	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5787	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5788	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5789	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5790	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5791			      HDA_OUTPUT),
5792	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5793	{ } /* end */
5794};
5795
5796static struct hda_verb alc260_hp_unsol_verbs[] = {
5797	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5798	{},
5799};
5800
5801static void alc260_hp_automute(struct hda_codec *codec)
5802{
5803	struct alc_spec *spec = codec->spec;
5804
5805	spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5806	alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5807}
5808
5809static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5810{
5811	if ((res >> 26) == ALC880_HP_EVENT)
5812		alc260_hp_automute(codec);
5813}
5814
5815static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5816	{
5817		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5818		.name = "Master Playback Switch",
5819		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5820		.info = snd_ctl_boolean_mono_info,
5821		.get = alc260_hp_master_sw_get,
5822		.put = alc260_hp_master_sw_put,
5823		.private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5824	},
5825	HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5826	HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5827	HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5828	HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5829	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5830	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5831	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5832	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5833	{ } /* end */
5834};
5835
5836static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5837	.ops = &snd_hda_bind_vol,
5838	.values = {
5839		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5840		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5841		HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5842		0
5843	},
5844};
5845
5846static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5847	.ops = &snd_hda_bind_sw,
5848	.values = {
5849		HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5850		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5851		0
5852	},
5853};
5854
5855static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5856	HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5857	HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5858	HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5859	HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5860	{ } /* end */
5861};
5862
5863static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5864	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5865	{},
5866};
5867
5868static void alc260_hp_3013_automute(struct hda_codec *codec)
5869{
5870	struct alc_spec *spec = codec->spec;
5871
5872	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5873	alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5874}
5875
5876static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5877				       unsigned int res)
5878{
5879	if ((res >> 26) == ALC880_HP_EVENT)
5880		alc260_hp_3013_automute(codec);
5881}
5882
5883static void alc260_hp_3012_automute(struct hda_codec *codec)
5884{
5885	unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5886
5887	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5888			    bits);
5889	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5890			    bits);
5891	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5892			    bits);
5893}
5894
5895static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5896				       unsigned int res)
5897{
5898	if ((res >> 26) == ALC880_HP_EVENT)
5899		alc260_hp_3012_automute(codec);
5900}
5901
5902/* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5903 * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5904 */
5905static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5906	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5907	HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5908	ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5909	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5910	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5911	HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5912	HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5913	ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5914	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5915	HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5916	{ } /* end */
5917};
5918
5919/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5920 * versions of the ALC260 don't act on requests to enable mic bias from NID
5921 * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5922 * datasheet doesn't mention this restriction.  At this stage it's not clear
5923 * whether this behaviour is intentional or is a hardware bug in chip
5924 * revisions available in early 2006.  Therefore for now allow the
5925 * "Headphone Jack Mode" control to span all choices, but if it turns out
5926 * that the lack of mic bias for this NID is intentional we could change the
5927 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5928 *
5929 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5930 * don't appear to make the mic bias available from the "line" jack, even
5931 * though the NID used for this jack (0x14) can supply it.  The theory is
5932 * that perhaps Acer have included blocking capacitors between the ALC260
5933 * and the output jack.  If this turns out to be the case for all such
5934 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5935 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5936 *
5937 * The C20x Tablet series have a mono internal speaker which is controlled
5938 * via the chip's Mono sum widget and pin complex, so include the necessary
5939 * controls for such models.  On models without a "mono speaker" the control
5940 * won't do anything.
5941 */
5942static struct snd_kcontrol_new alc260_acer_mixer[] = {
5943	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5944	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5945	ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5946	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5947			      HDA_OUTPUT),
5948	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5949			   HDA_INPUT),
5950	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5951	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5952	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5953	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5954	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5955	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5956	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5957	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5958	{ } /* end */
5959};
5960
5961/* Maxdata Favorit 100XS: one output and one input (0x12) jack
5962 */
5963static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5964	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5965	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5966	ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5967	HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5968	HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5969	ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5970	{ } /* end */
5971};
5972
5973/* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5974 * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5975 */
5976static struct snd_kcontrol_new alc260_will_mixer[] = {
5977	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5978	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5979	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5980	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5981	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5982	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5983	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5984	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5985	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5986	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5987	{ } /* end */
5988};
5989
5990/* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5991 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5992 */
5993static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5994	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5995	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5996	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5997	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5998	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5999	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6000	HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6001	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6002	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6003	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6004	{ } /* end */
6005};
6006
6007/*
6008 * initialization verbs
6009 */
6010static struct hda_verb alc260_init_verbs[] = {
6011	/* Line In pin widget for input */
6012	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6013	/* CD pin widget for input */
6014	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6015	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6016	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6017	/* Mic2 (front panel) pin widget for input and vref at 80% */
6018	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6019	/* LINE-2 is used for line-out in rear */
6020	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6021	/* select line-out */
6022	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6023	/* LINE-OUT pin */
6024	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6025	/* enable HP */
6026	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6027	/* enable Mono */
6028	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6029	/* mute capture amp left and right */
6030	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6031	/* set connection select to line in (default select for this ADC) */
6032	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6033	/* mute capture amp left and right */
6034	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6035	/* set connection select to line in (default select for this ADC) */
6036	{0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6037	/* set vol=0 Line-Out mixer amp left and right */
6038	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6039	/* unmute pin widget amp left and right (no gain on this amp) */
6040	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6041	/* set vol=0 HP mixer amp left and right */
6042	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6043	/* unmute pin widget amp left and right (no gain on this amp) */
6044	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6045	/* set vol=0 Mono mixer amp left and right */
6046	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6047	/* unmute pin widget amp left and right (no gain on this amp) */
6048	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6049	/* unmute LINE-2 out pin */
6050	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6051	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6052	 * Line In 2 = 0x03
6053	 */
6054	/* mute analog inputs */
6055	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6056	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6057	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6058	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6059	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6060	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6061	/* mute Front out path */
6062	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6063	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6064	/* mute Headphone out path */
6065	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6066	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6067	/* mute Mono out path */
6068	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6069	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6070	{ }
6071};
6072
6073#if 0 /* should be identical with alc260_init_verbs? */
6074static struct hda_verb alc260_hp_init_verbs[] = {
6075	/* Headphone and output */
6076	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6077	/* mono output */
6078	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6079	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6080	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6081	/* Mic2 (front panel) pin widget for input and vref at 80% */
6082	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6083	/* Line In pin widget for input */
6084	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6085	/* Line-2 pin widget for output */
6086	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6087	/* CD pin widget for input */
6088	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6089	/* unmute amp left and right */
6090	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6091	/* set connection select to line in (default select for this ADC) */
6092	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6093	/* unmute Line-Out mixer amp left and right (volume = 0) */
6094	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6095	/* mute pin widget amp left and right (no gain on this amp) */
6096	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6097	/* unmute HP mixer amp left and right (volume = 0) */
6098	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6099	/* mute pin widget amp left and right (no gain on this amp) */
6100	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6101	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6102	 * Line In 2 = 0x03
6103	 */
6104	/* mute analog inputs */
6105	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6106	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6107	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6108	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6109	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6110	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6111	/* Unmute Front out path */
6112	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6113	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6114	/* Unmute Headphone out path */
6115	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6116	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6117	/* Unmute Mono out path */
6118	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6119	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6120	{ }
6121};
6122#endif
6123
6124static struct hda_verb alc260_hp_3013_init_verbs[] = {
6125	/* Line out and output */
6126	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6127	/* mono output */
6128	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6129	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6130	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6131	/* Mic2 (front panel) pin widget for input and vref at 80% */
6132	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6133	/* Line In pin widget for input */
6134	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6135	/* Headphone pin widget for output */
6136	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6137	/* CD pin widget for input */
6138	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6139	/* unmute amp left and right */
6140	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6141	/* set connection select to line in (default select for this ADC) */
6142	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6143	/* unmute Line-Out mixer amp left and right (volume = 0) */
6144	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6145	/* mute pin widget amp left and right (no gain on this amp) */
6146	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6147	/* unmute HP mixer amp left and right (volume = 0) */
6148	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6149	/* mute pin widget amp left and right (no gain on this amp) */
6150	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6151	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6152	 * Line In 2 = 0x03
6153	 */
6154	/* mute analog inputs */
6155	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6156	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6157	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6158	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6159	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6160	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6161	/* Unmute Front out path */
6162	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6163	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6164	/* Unmute Headphone out path */
6165	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6166	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6167	/* Unmute Mono out path */
6168	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6169	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6170	{ }
6171};
6172
6173/* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6174 * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6175 * audio = 0x16, internal speaker = 0x10.
6176 */
6177static struct hda_verb alc260_fujitsu_init_verbs[] = {
6178	/* Disable all GPIOs */
6179	{0x01, AC_VERB_SET_GPIO_MASK, 0},
6180	/* Internal speaker is connected to headphone pin */
6181	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6182	/* Headphone/Line-out jack connects to Line1 pin; make it an output */
6183	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6184	/* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6185	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6186	/* Ensure all other unused pins are disabled and muted. */
6187	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6188	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6189	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6190	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6191	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6192	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6193	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6194	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6195
6196	/* Disable digital (SPDIF) pins */
6197	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6198	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6199
6200	/* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6201	 * when acting as an output.
6202	 */
6203	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6204
6205	/* Start with output sum widgets muted and their output gains at min */
6206	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6207	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6208	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6209	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6210	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6211	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6212	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6213	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6214	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6215
6216	/* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6217	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6218	/* Unmute Line1 pin widget output buffer since it starts as an output.
6219	 * If the pin mode is changed by the user the pin mode control will
6220	 * take care of enabling the pin's input/output buffers as needed.
6221	 * Therefore there's no need to enable the input buffer at this
6222	 * stage.
6223	 */
6224	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6225	/* Unmute input buffer of pin widget used for Line-in (no equiv
6226	 * mixer ctrl)
6227	 */
6228	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6229
6230	/* Mute capture amp left and right */
6231	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6232	/* Set ADC connection select to match default mixer setting - line
6233	 * in (on mic1 pin)
6234	 */
6235	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6236
6237	/* Do the same for the second ADC: mute capture input amp and
6238	 * set ADC connection to line in (on mic1 pin)
6239	 */
6240	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6241	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6242
6243	/* Mute all inputs to mixer widget (even unconnected ones) */
6244	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6245	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6246	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6247	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6248	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6249	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6250	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6251	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6252
6253	{ }
6254};
6255
6256/* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6257 * similar laptops (adapted from Fujitsu init verbs).
6258 */
6259static struct hda_verb alc260_acer_init_verbs[] = {
6260	/* On TravelMate laptops, GPIO 0 enables the internal speaker and
6261	 * the headphone jack.  Turn this on and rely on the standard mute
6262	 * methods whenever the user wants to turn these outputs off.
6263	 */
6264	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6265	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6266	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6267	/* Internal speaker/Headphone jack is connected to Line-out pin */
6268	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6269	/* Internal microphone/Mic jack is connected to Mic1 pin */
6270	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6271	/* Line In jack is connected to Line1 pin */
6272	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6273	/* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6274	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6275	/* Ensure all other unused pins are disabled and muted. */
6276	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6277	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6278	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6279	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6280	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6281	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6282	/* Disable digital (SPDIF) pins */
6283	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6284	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6285
6286	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6287	 * bus when acting as outputs.
6288	 */
6289	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6290	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6291
6292	/* Start with output sum widgets muted and their output gains at min */
6293	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6294	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6295	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6296	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6297	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6298	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6299	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6300	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6301	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6302
6303	/* Unmute Line-out pin widget amp left and right
6304	 * (no equiv mixer ctrl)
6305	 */
6306	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6307	/* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6308	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6309	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
6310	 * inputs. If the pin mode is changed by the user the pin mode control
6311	 * will take care of enabling the pin's input/output buffers as needed.
6312	 * Therefore there's no need to enable the input buffer at this
6313	 * stage.
6314	 */
6315	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6316	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6317
6318	/* Mute capture amp left and right */
6319	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6320	/* Set ADC connection select to match default mixer setting - mic
6321	 * (on mic1 pin)
6322	 */
6323	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6324
6325	/* Do similar with the second ADC: mute capture input amp and
6326	 * set ADC connection to mic to match ALSA's default state.
6327	 */
6328	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6329	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6330
6331	/* Mute all inputs to mixer widget (even unconnected ones) */
6332	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6333	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6334	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6335	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6336	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6337	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6338	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6339	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6340
6341	{ }
6342};
6343
6344/* Initialisation sequence for Maxdata Favorit 100XS
6345 * (adapted from Acer init verbs).
6346 */
6347static struct hda_verb alc260_favorit100_init_verbs[] = {
6348	/* GPIO 0 enables the output jack.
6349	 * Turn this on and rely on the standard mute
6350	 * methods whenever the user wants to turn these outputs off.
6351	 */
6352	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6353	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6354	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6355	/* Line/Mic input jack is connected to Mic1 pin */
6356	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6357	/* Ensure all other unused pins are disabled and muted. */
6358	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6359	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6360	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6361	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6362	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6363	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6364	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6365	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6366	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6367	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6368	/* Disable digital (SPDIF) pins */
6369	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6370	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6371
6372	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6373	 * bus when acting as outputs.
6374	 */
6375	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6376	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6377
6378	/* Start with output sum widgets muted and their output gains at min */
6379	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6380	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6381	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6382	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6383	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6384	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6385	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6386	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6387	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6388
6389	/* Unmute Line-out pin widget amp left and right
6390	 * (no equiv mixer ctrl)
6391	 */
6392	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6393	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
6394	 * inputs. If the pin mode is changed by the user the pin mode control
6395	 * will take care of enabling the pin's input/output buffers as needed.
6396	 * Therefore there's no need to enable the input buffer at this
6397	 * stage.
6398	 */
6399	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6400
6401	/* Mute capture amp left and right */
6402	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6403	/* Set ADC connection select to match default mixer setting - mic
6404	 * (on mic1 pin)
6405	 */
6406	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6407
6408	/* Do similar with the second ADC: mute capture input amp and
6409	 * set ADC connection to mic to match ALSA's default state.
6410	 */
6411	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6412	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6413
6414	/* Mute all inputs to mixer widget (even unconnected ones) */
6415	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6416	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6417	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6418	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6419	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6420	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6421	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6422	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6423
6424	{ }
6425};
6426
6427static struct hda_verb alc260_will_verbs[] = {
6428	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6429	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6430	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6431	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6432	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6433	{0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6434	{}
6435};
6436
6437static struct hda_verb alc260_replacer_672v_verbs[] = {
6438	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6439	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6440	{0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6441
6442	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6443	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6444	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6445
6446	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6447	{}
6448};
6449
6450/* toggle speaker-output according to the hp-jack state */
6451static void alc260_replacer_672v_automute(struct hda_codec *codec)
6452{
6453        unsigned int present;
6454
6455	/* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6456	present = snd_hda_jack_detect(codec, 0x0f);
6457	if (present) {
6458		snd_hda_codec_write_cache(codec, 0x01, 0,
6459					  AC_VERB_SET_GPIO_DATA, 1);
6460		snd_hda_codec_write_cache(codec, 0x0f, 0,
6461					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6462					  PIN_HP);
6463	} else {
6464		snd_hda_codec_write_cache(codec, 0x01, 0,
6465					  AC_VERB_SET_GPIO_DATA, 0);
6466		snd_hda_codec_write_cache(codec, 0x0f, 0,
6467					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6468					  PIN_OUT);
6469	}
6470}
6471
6472static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6473                                       unsigned int res)
6474{
6475        if ((res >> 26) == ALC880_HP_EVENT)
6476                alc260_replacer_672v_automute(codec);
6477}
6478
6479static struct hda_verb alc260_hp_dc7600_verbs[] = {
6480	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6481	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6482	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6483	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6484	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6485	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6486	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6487	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6488	{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6489	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6490	{}
6491};
6492
6493/* Test configuration for debugging, modelled after the ALC880 test
6494 * configuration.
6495 */
6496#ifdef CONFIG_SND_DEBUG
6497static hda_nid_t alc260_test_dac_nids[1] = {
6498	0x02,
6499};
6500static hda_nid_t alc260_test_adc_nids[2] = {
6501	0x04, 0x05,
6502};
6503/* For testing the ALC260, each input MUX needs its own definition since
6504 * the signal assignments are different.  This assumes that the first ADC
6505 * is NID 0x04.
6506 */
6507static struct hda_input_mux alc260_test_capture_sources[2] = {
6508	{
6509		.num_items = 7,
6510		.items = {
6511			{ "MIC1 pin", 0x0 },
6512			{ "MIC2 pin", 0x1 },
6513			{ "LINE1 pin", 0x2 },
6514			{ "LINE2 pin", 0x3 },
6515			{ "CD pin", 0x4 },
6516			{ "LINE-OUT pin", 0x5 },
6517			{ "HP-OUT pin", 0x6 },
6518		},
6519        },
6520	{
6521		.num_items = 8,
6522		.items = {
6523			{ "MIC1 pin", 0x0 },
6524			{ "MIC2 pin", 0x1 },
6525			{ "LINE1 pin", 0x2 },
6526			{ "LINE2 pin", 0x3 },
6527			{ "CD pin", 0x4 },
6528			{ "Mixer", 0x5 },
6529			{ "LINE-OUT pin", 0x6 },
6530			{ "HP-OUT pin", 0x7 },
6531		},
6532        },
6533};
6534static struct snd_kcontrol_new alc260_test_mixer[] = {
6535	/* Output driver widgets */
6536	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6537	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6538	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6539	HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6540	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6541	HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6542
6543	/* Modes for retasking pin widgets
6544	 * Note: the ALC260 doesn't seem to act on requests to enable mic
6545         * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6546         * mention this restriction.  At this stage it's not clear whether
6547         * this behaviour is intentional or is a hardware bug in chip
6548         * revisions available at least up until early 2006.  Therefore for
6549         * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6550         * choices, but if it turns out that the lack of mic bias for these
6551         * NIDs is intentional we could change their modes from
6552         * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6553	 */
6554	ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6555	ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6556	ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6557	ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6558	ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6559	ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6560
6561	/* Loopback mixer controls */
6562	HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6563	HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6564	HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6565	HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6566	HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6567	HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6568	HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6569	HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6570	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6571	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6572	HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6573	HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6574	HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6575	HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6576
6577	/* Controls for GPIO pins, assuming they are configured as outputs */
6578	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6579	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6580	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6581	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6582
6583	/* Switches to allow the digital IO pins to be enabled.  The datasheet
6584	 * is ambigious as to which NID is which; testing on laptops which
6585	 * make this output available should provide clarification.
6586	 */
6587	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6588	ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6589
6590	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
6591	 * this output to turn on an external amplifier.
6592	 */
6593	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6594	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6595
6596	{ } /* end */
6597};
6598static struct hda_verb alc260_test_init_verbs[] = {
6599	/* Enable all GPIOs as outputs with an initial value of 0 */
6600	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6601	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6602	{0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6603
6604	/* Enable retasking pins as output, initially without power amp */
6605	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6606	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6607	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6608	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6609	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6610	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6611
6612	/* Disable digital (SPDIF) pins initially, but users can enable
6613	 * them via a mixer switch.  In the case of SPDIF-out, this initverb
6614	 * payload also sets the generation to 0, output to be in "consumer"
6615	 * PCM format, copyright asserted, no pre-emphasis and no validity
6616	 * control.
6617	 */
6618	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6619	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6620
6621	/* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6622	 * OUT1 sum bus when acting as an output.
6623	 */
6624	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6625	{0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6626	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6627	{0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6628
6629	/* Start with output sum widgets muted and their output gains at min */
6630	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6631	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6632	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6633	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6634	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6635	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6636	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6637	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6638	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6639
6640	/* Unmute retasking pin widget output buffers since the default
6641	 * state appears to be output.  As the pin mode is changed by the
6642	 * user the pin mode control will take care of enabling the pin's
6643	 * input/output buffers as needed.
6644	 */
6645	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6646	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6647	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6648	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6649	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6650	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6651	/* Also unmute the mono-out pin widget */
6652	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6653
6654	/* Mute capture amp left and right */
6655	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6656	/* Set ADC connection select to match default mixer setting (mic1
6657	 * pin)
6658	 */
6659	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6660
6661	/* Do the same for the second ADC: mute capture input amp and
6662	 * set ADC connection to mic1 pin
6663	 */
6664	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6665	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6666
6667	/* Mute all inputs to mixer widget (even unconnected ones) */
6668	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6669	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6670	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6671	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6672	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6673	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6674	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6675	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6676
6677	{ }
6678};
6679#endif
6680
6681#define alc260_pcm_analog_playback	alc880_pcm_analog_alt_playback
6682#define alc260_pcm_analog_capture	alc880_pcm_analog_capture
6683
6684#define alc260_pcm_digital_playback	alc880_pcm_digital_playback
6685#define alc260_pcm_digital_capture	alc880_pcm_digital_capture
6686
6687/*
6688 * for BIOS auto-configuration
6689 */
6690
6691static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6692					const char *pfx, int *vol_bits)
6693{
6694	hda_nid_t nid_vol;
6695	unsigned long vol_val, sw_val;
6696	int err;
6697
6698	if (nid >= 0x0f && nid < 0x11) {
6699		nid_vol = nid - 0x7;
6700		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6701		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6702	} else if (nid == 0x11) {
6703		nid_vol = nid - 0x7;
6704		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6705		sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6706	} else if (nid >= 0x12 && nid <= 0x15) {
6707		nid_vol = 0x08;
6708		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6709		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6710	} else
6711		return 0; /* N/A */
6712
6713	if (!(*vol_bits & (1 << nid_vol))) {
6714		/* first control for the volume widget */
6715		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6716		if (err < 0)
6717			return err;
6718		*vol_bits |= (1 << nid_vol);
6719	}
6720	err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6721	if (err < 0)
6722		return err;
6723	return 1;
6724}
6725
6726/* add playback controls from the parsed DAC table */
6727static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6728					     const struct auto_pin_cfg *cfg)
6729{
6730	hda_nid_t nid;
6731	int err;
6732	int vols = 0;
6733
6734	spec->multiout.num_dacs = 1;
6735	spec->multiout.dac_nids = spec->private_dac_nids;
6736	spec->multiout.dac_nids[0] = 0x02;
6737
6738	nid = cfg->line_out_pins[0];
6739	if (nid) {
6740		const char *pfx;
6741		if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6742			pfx = "Master";
6743		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6744			pfx = "Speaker";
6745		else
6746			pfx = "Front";
6747		err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6748		if (err < 0)
6749			return err;
6750	}
6751
6752	nid = cfg->speaker_pins[0];
6753	if (nid) {
6754		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6755		if (err < 0)
6756			return err;
6757	}
6758
6759	nid = cfg->hp_pins[0];
6760	if (nid) {
6761		err = alc260_add_playback_controls(spec, nid, "Headphone",
6762						   &vols);
6763		if (err < 0)
6764			return err;
6765	}
6766	return 0;
6767}
6768
6769/* create playback/capture controls for input pins */
6770static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6771						const struct auto_pin_cfg *cfg)
6772{
6773	return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6774}
6775
6776static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6777					      hda_nid_t nid, int pin_type,
6778					      int sel_idx)
6779{
6780	alc_set_pin_output(codec, nid, pin_type);
6781	/* need the manual connection? */
6782	if (nid >= 0x12) {
6783		int idx = nid - 0x12;
6784		snd_hda_codec_write(codec, idx + 0x0b, 0,
6785				    AC_VERB_SET_CONNECT_SEL, sel_idx);
6786	}
6787}
6788
6789static void alc260_auto_init_multi_out(struct hda_codec *codec)
6790{
6791	struct alc_spec *spec = codec->spec;
6792	hda_nid_t nid;
6793
6794	nid = spec->autocfg.line_out_pins[0];
6795	if (nid) {
6796		int pin_type = get_pin_type(spec->autocfg.line_out_type);
6797		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6798	}
6799
6800	nid = spec->autocfg.speaker_pins[0];
6801	if (nid)
6802		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6803
6804	nid = spec->autocfg.hp_pins[0];
6805	if (nid)
6806		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6807}
6808
6809#define ALC260_PIN_CD_NID		0x16
6810static void alc260_auto_init_analog_input(struct hda_codec *codec)
6811{
6812	struct alc_spec *spec = codec->spec;
6813	struct auto_pin_cfg *cfg = &spec->autocfg;
6814	int i;
6815
6816	for (i = 0; i < cfg->num_inputs; i++) {
6817		hda_nid_t nid = cfg->inputs[i].pin;
6818		if (nid >= 0x12) {
6819			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6820			if (nid != ALC260_PIN_CD_NID &&
6821			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6822				snd_hda_codec_write(codec, nid, 0,
6823						    AC_VERB_SET_AMP_GAIN_MUTE,
6824						    AMP_OUT_MUTE);
6825		}
6826	}
6827}
6828
6829#define alc260_auto_init_input_src	alc880_auto_init_input_src
6830
6831/*
6832 * generic initialization of ADC, input mixers and output mixers
6833 */
6834static struct hda_verb alc260_volume_init_verbs[] = {
6835	/*
6836	 * Unmute ADC0-1 and set the default input to mic-in
6837	 */
6838	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6839	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6840	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6841	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6842
6843	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6844	 * mixer widget
6845	 * Note: PASD motherboards uses the Line In 2 as the input for
6846	 * front panel mic (mic 2)
6847	 */
6848	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6849	/* mute analog inputs */
6850	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6851	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6852	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6853	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6854	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6855
6856	/*
6857	 * Set up output mixers (0x08 - 0x0a)
6858	 */
6859	/* set vol=0 to output mixers */
6860	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6861	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6862	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6863	/* set up input amps for analog loopback */
6864	/* Amp Indices: DAC = 0, mixer = 1 */
6865	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6866	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6867	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6868	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6869	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6870	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6871
6872	{ }
6873};
6874
6875static int alc260_parse_auto_config(struct hda_codec *codec)
6876{
6877	struct alc_spec *spec = codec->spec;
6878	int err;
6879	static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6880
6881	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6882					   alc260_ignore);
6883	if (err < 0)
6884		return err;
6885	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6886	if (err < 0)
6887		return err;
6888	if (!spec->kctls.list)
6889		return 0; /* can't find valid BIOS pin config */
6890	err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6891	if (err < 0)
6892		return err;
6893
6894	spec->multiout.max_channels = 2;
6895
6896	if (spec->autocfg.dig_outs)
6897		spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6898	if (spec->kctls.list)
6899		add_mixer(spec, spec->kctls.list);
6900
6901	add_verb(spec, alc260_volume_init_verbs);
6902
6903	spec->num_mux_defs = 1;
6904	spec->input_mux = &spec->private_imux[0];
6905
6906	alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6907
6908	return 1;
6909}
6910
6911/* additional initialization for auto-configuration model */
6912static void alc260_auto_init(struct hda_codec *codec)
6913{
6914	struct alc_spec *spec = codec->spec;
6915	alc260_auto_init_multi_out(codec);
6916	alc260_auto_init_analog_input(codec);
6917	alc260_auto_init_input_src(codec);
6918	alc_auto_init_digital(codec);
6919	if (spec->unsol_event)
6920		alc_inithook(codec);
6921}
6922
6923#ifdef CONFIG_SND_HDA_POWER_SAVE
6924static struct hda_amp_list alc260_loopbacks[] = {
6925	{ 0x07, HDA_INPUT, 0 },
6926	{ 0x07, HDA_INPUT, 1 },
6927	{ 0x07, HDA_INPUT, 2 },
6928	{ 0x07, HDA_INPUT, 3 },
6929	{ 0x07, HDA_INPUT, 4 },
6930	{ } /* end */
6931};
6932#endif
6933
6934/*
6935 * Pin config fixes
6936 */
6937enum {
6938	PINFIX_HP_DC5750,
6939};
6940
6941static const struct alc_fixup alc260_fixups[] = {
6942	[PINFIX_HP_DC5750] = {
6943		.pins = (const struct alc_pincfg[]) {
6944			{ 0x11, 0x90130110 }, /* speaker */
6945			{ }
6946		}
6947	},
6948};
6949
6950static struct snd_pci_quirk alc260_fixup_tbl[] = {
6951	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
6952	{}
6953};
6954
6955/*
6956 * ALC260 configurations
6957 */
6958static const char *alc260_models[ALC260_MODEL_LAST] = {
6959	[ALC260_BASIC]		= "basic",
6960	[ALC260_HP]		= "hp",
6961	[ALC260_HP_3013]	= "hp-3013",
6962	[ALC260_HP_DC7600]	= "hp-dc7600",
6963	[ALC260_FUJITSU_S702X]	= "fujitsu",
6964	[ALC260_ACER]		= "acer",
6965	[ALC260_WILL]		= "will",
6966	[ALC260_REPLACER_672V]	= "replacer",
6967	[ALC260_FAVORIT100]	= "favorit100",
6968#ifdef CONFIG_SND_DEBUG
6969	[ALC260_TEST]		= "test",
6970#endif
6971	[ALC260_AUTO]		= "auto",
6972};
6973
6974static struct snd_pci_quirk alc260_cfg_tbl[] = {
6975	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6976	SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6977	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6978	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6979	SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6980	SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6981	SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6982	SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6983	SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6984	SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6985	SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6986	SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6987	SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6988	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6989	SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6990	SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6991	SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6992	SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6993	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6994	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6995	{}
6996};
6997
6998static struct alc_config_preset alc260_presets[] = {
6999	[ALC260_BASIC] = {
7000		.mixers = { alc260_base_output_mixer,
7001			    alc260_input_mixer },
7002		.init_verbs = { alc260_init_verbs },
7003		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7004		.dac_nids = alc260_dac_nids,
7005		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7006		.adc_nids = alc260_dual_adc_nids,
7007		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7008		.channel_mode = alc260_modes,
7009		.input_mux = &alc260_capture_source,
7010	},
7011	[ALC260_HP] = {
7012		.mixers = { alc260_hp_output_mixer,
7013			    alc260_input_mixer },
7014		.init_verbs = { alc260_init_verbs,
7015				alc260_hp_unsol_verbs },
7016		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7017		.dac_nids = alc260_dac_nids,
7018		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7019		.adc_nids = alc260_adc_nids_alt,
7020		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7021		.channel_mode = alc260_modes,
7022		.input_mux = &alc260_capture_source,
7023		.unsol_event = alc260_hp_unsol_event,
7024		.init_hook = alc260_hp_automute,
7025	},
7026	[ALC260_HP_DC7600] = {
7027		.mixers = { alc260_hp_dc7600_mixer,
7028			    alc260_input_mixer },
7029		.init_verbs = { alc260_init_verbs,
7030				alc260_hp_dc7600_verbs },
7031		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7032		.dac_nids = alc260_dac_nids,
7033		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7034		.adc_nids = alc260_adc_nids_alt,
7035		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7036		.channel_mode = alc260_modes,
7037		.input_mux = &alc260_capture_source,
7038		.unsol_event = alc260_hp_3012_unsol_event,
7039		.init_hook = alc260_hp_3012_automute,
7040	},
7041	[ALC260_HP_3013] = {
7042		.mixers = { alc260_hp_3013_mixer,
7043			    alc260_input_mixer },
7044		.init_verbs = { alc260_hp_3013_init_verbs,
7045				alc260_hp_3013_unsol_verbs },
7046		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7047		.dac_nids = alc260_dac_nids,
7048		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7049		.adc_nids = alc260_adc_nids_alt,
7050		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7051		.channel_mode = alc260_modes,
7052		.input_mux = &alc260_capture_source,
7053		.unsol_event = alc260_hp_3013_unsol_event,
7054		.init_hook = alc260_hp_3013_automute,
7055	},
7056	[ALC260_FUJITSU_S702X] = {
7057		.mixers = { alc260_fujitsu_mixer },
7058		.init_verbs = { alc260_fujitsu_init_verbs },
7059		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7060		.dac_nids = alc260_dac_nids,
7061		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7062		.adc_nids = alc260_dual_adc_nids,
7063		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7064		.channel_mode = alc260_modes,
7065		.num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7066		.input_mux = alc260_fujitsu_capture_sources,
7067	},
7068	[ALC260_ACER] = {
7069		.mixers = { alc260_acer_mixer },
7070		.init_verbs = { alc260_acer_init_verbs },
7071		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7072		.dac_nids = alc260_dac_nids,
7073		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7074		.adc_nids = alc260_dual_adc_nids,
7075		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7076		.channel_mode = alc260_modes,
7077		.num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7078		.input_mux = alc260_acer_capture_sources,
7079	},
7080	[ALC260_FAVORIT100] = {
7081		.mixers = { alc260_favorit100_mixer },
7082		.init_verbs = { alc260_favorit100_init_verbs },
7083		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7084		.dac_nids = alc260_dac_nids,
7085		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7086		.adc_nids = alc260_dual_adc_nids,
7087		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7088		.channel_mode = alc260_modes,
7089		.num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7090		.input_mux = alc260_favorit100_capture_sources,
7091	},
7092	[ALC260_WILL] = {
7093		.mixers = { alc260_will_mixer },
7094		.init_verbs = { alc260_init_verbs, alc260_will_verbs },
7095		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7096		.dac_nids = alc260_dac_nids,
7097		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7098		.adc_nids = alc260_adc_nids,
7099		.dig_out_nid = ALC260_DIGOUT_NID,
7100		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7101		.channel_mode = alc260_modes,
7102		.input_mux = &alc260_capture_source,
7103	},
7104	[ALC260_REPLACER_672V] = {
7105		.mixers = { alc260_replacer_672v_mixer },
7106		.init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7107		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7108		.dac_nids = alc260_dac_nids,
7109		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7110		.adc_nids = alc260_adc_nids,
7111		.dig_out_nid = ALC260_DIGOUT_NID,
7112		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7113		.channel_mode = alc260_modes,
7114		.input_mux = &alc260_capture_source,
7115		.unsol_event = alc260_replacer_672v_unsol_event,
7116		.init_hook = alc260_replacer_672v_automute,
7117	},
7118#ifdef CONFIG_SND_DEBUG
7119	[ALC260_TEST] = {
7120		.mixers = { alc260_test_mixer },
7121		.init_verbs = { alc260_test_init_verbs },
7122		.num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7123		.dac_nids = alc260_test_dac_nids,
7124		.num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7125		.adc_nids = alc260_test_adc_nids,
7126		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7127		.channel_mode = alc260_modes,
7128		.num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7129		.input_mux = alc260_test_capture_sources,
7130	},
7131#endif
7132};
7133
7134static int patch_alc260(struct hda_codec *codec)
7135{
7136	struct alc_spec *spec;
7137	int err, board_config;
7138
7139	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7140	if (spec == NULL)
7141		return -ENOMEM;
7142
7143	codec->spec = spec;
7144
7145	board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7146						  alc260_models,
7147						  alc260_cfg_tbl);
7148	if (board_config < 0) {
7149		snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7150			   codec->chip_name);
7151		board_config = ALC260_AUTO;
7152	}
7153
7154	if (board_config == ALC260_AUTO)
7155		alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7156
7157	if (board_config == ALC260_AUTO) {
7158		/* automatic parse from the BIOS config */
7159		err = alc260_parse_auto_config(codec);
7160		if (err < 0) {
7161			alc_free(codec);
7162			return err;
7163		} else if (!err) {
7164			printk(KERN_INFO
7165			       "hda_codec: Cannot set up configuration "
7166			       "from BIOS.  Using base mode...\n");
7167			board_config = ALC260_BASIC;
7168		}
7169	}
7170
7171	err = snd_hda_attach_beep_device(codec, 0x1);
7172	if (err < 0) {
7173		alc_free(codec);
7174		return err;
7175	}
7176
7177	if (board_config != ALC260_AUTO)
7178		setup_preset(codec, &alc260_presets[board_config]);
7179
7180	spec->stream_analog_playback = &alc260_pcm_analog_playback;
7181	spec->stream_analog_capture = &alc260_pcm_analog_capture;
7182	spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7183
7184	spec->stream_digital_playback = &alc260_pcm_digital_playback;
7185	spec->stream_digital_capture = &alc260_pcm_digital_capture;
7186
7187	if (!spec->adc_nids && spec->input_mux) {
7188		/* check whether NID 0x04 is valid */
7189		unsigned int wcap = get_wcaps(codec, 0x04);
7190		wcap = get_wcaps_type(wcap);
7191		/* get type */
7192		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7193			spec->adc_nids = alc260_adc_nids_alt;
7194			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7195		} else {
7196			spec->adc_nids = alc260_adc_nids;
7197			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7198		}
7199	}
7200	set_capture_mixer(codec);
7201	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7202
7203	if (board_config == ALC260_AUTO)
7204		alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7205
7206	spec->vmaster_nid = 0x08;
7207
7208	codec->patch_ops = alc_patch_ops;
7209	if (board_config == ALC260_AUTO)
7210		spec->init_hook = alc260_auto_init;
7211#ifdef CONFIG_SND_HDA_POWER_SAVE
7212	if (!spec->loopback.amplist)
7213		spec->loopback.amplist = alc260_loopbacks;
7214#endif
7215
7216	return 0;
7217}
7218
7219
7220/*
7221 * ALC882/883/885/888/889 support
7222 *
7223 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7224 * configuration.  Each pin widget can choose any input DACs and a mixer.
7225 * Each ADC is connected from a mixer of all inputs.  This makes possible
7226 * 6-channel independent captures.
7227 *
7228 * In addition, an independent DAC for the multi-playback (not used in this
7229 * driver yet).
7230 */
7231#define ALC882_DIGOUT_NID	0x06
7232#define ALC882_DIGIN_NID	0x0a
7233#define ALC883_DIGOUT_NID	ALC882_DIGOUT_NID
7234#define ALC883_DIGIN_NID	ALC882_DIGIN_NID
7235#define ALC1200_DIGOUT_NID	0x10
7236
7237
7238static struct hda_channel_mode alc882_ch_modes[1] = {
7239	{ 8, NULL }
7240};
7241
7242/* DACs */
7243static hda_nid_t alc882_dac_nids[4] = {
7244	/* front, rear, clfe, rear_surr */
7245	0x02, 0x03, 0x04, 0x05
7246};
7247#define alc883_dac_nids		alc882_dac_nids
7248
7249/* ADCs */
7250#define alc882_adc_nids		alc880_adc_nids
7251#define alc882_adc_nids_alt	alc880_adc_nids_alt
7252#define alc883_adc_nids		alc882_adc_nids_alt
7253static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7254static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7255#define alc889_adc_nids		alc880_adc_nids
7256
7257static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7258static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7259#define alc883_capsrc_nids	alc882_capsrc_nids_alt
7260static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7261#define alc889_capsrc_nids	alc882_capsrc_nids
7262
7263/* input MUX */
7264/* FIXME: should be a matrix-type input source selection */
7265
7266static struct hda_input_mux alc882_capture_source = {
7267	.num_items = 4,
7268	.items = {
7269		{ "Mic", 0x0 },
7270		{ "Front Mic", 0x1 },
7271		{ "Line", 0x2 },
7272		{ "CD", 0x4 },
7273	},
7274};
7275
7276#define alc883_capture_source	alc882_capture_source
7277
7278static struct hda_input_mux alc889_capture_source = {
7279	.num_items = 3,
7280	.items = {
7281		{ "Front Mic", 0x0 },
7282		{ "Mic", 0x3 },
7283		{ "Line", 0x2 },
7284	},
7285};
7286
7287static struct hda_input_mux mb5_capture_source = {
7288	.num_items = 3,
7289	.items = {
7290		{ "Mic", 0x1 },
7291		{ "Line", 0x7 },
7292		{ "CD", 0x4 },
7293	},
7294};
7295
7296static struct hda_input_mux macmini3_capture_source = {
7297	.num_items = 2,
7298	.items = {
7299		{ "Line", 0x2 },
7300		{ "CD", 0x4 },
7301	},
7302};
7303
7304static struct hda_input_mux alc883_3stack_6ch_intel = {
7305	.num_items = 4,
7306	.items = {
7307		{ "Mic", 0x1 },
7308		{ "Front Mic", 0x0 },
7309		{ "Line", 0x2 },
7310		{ "CD", 0x4 },
7311	},
7312};
7313
7314static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7315	.num_items = 2,
7316	.items = {
7317		{ "Mic", 0x1 },
7318		{ "Line", 0x2 },
7319	},
7320};
7321
7322static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7323	.num_items = 4,
7324	.items = {
7325		{ "Mic", 0x0 },
7326		{ "Int Mic", 0x1 },
7327		{ "Line", 0x2 },
7328		{ "CD", 0x4 },
7329	},
7330};
7331
7332static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7333	.num_items = 2,
7334	.items = {
7335		{ "Mic", 0x0 },
7336		{ "Int Mic", 0x1 },
7337	},
7338};
7339
7340static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7341	.num_items = 3,
7342	.items = {
7343		{ "Mic", 0x0 },
7344		{ "Front Mic", 0x1 },
7345		{ "Line", 0x4 },
7346	},
7347};
7348
7349static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7350	.num_items = 2,
7351	.items = {
7352		{ "Mic", 0x0 },
7353		{ "Line", 0x2 },
7354	},
7355};
7356
7357static struct hda_input_mux alc889A_mb31_capture_source = {
7358	.num_items = 2,
7359	.items = {
7360		{ "Mic", 0x0 },
7361		/* Front Mic (0x01) unused */
7362		{ "Line", 0x2 },
7363		/* Line 2 (0x03) unused */
7364		/* CD (0x04) unused? */
7365	},
7366};
7367
7368static struct hda_input_mux alc889A_imac91_capture_source = {
7369	.num_items = 2,
7370	.items = {
7371		{ "Mic", 0x01 },
7372		{ "Line", 0x2 }, /* Not sure! */
7373	},
7374};
7375
7376/*
7377 * 2ch mode
7378 */
7379static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7380	{ 2, NULL }
7381};
7382
7383/*
7384 * 2ch mode
7385 */
7386static struct hda_verb alc882_3ST_ch2_init[] = {
7387	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7388	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7389	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7390	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7391	{ } /* end */
7392};
7393
7394/*
7395 * 4ch mode
7396 */
7397static struct hda_verb alc882_3ST_ch4_init[] = {
7398	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7399	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7400	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7401	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7402	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7403	{ } /* end */
7404};
7405
7406/*
7407 * 6ch mode
7408 */
7409static struct hda_verb alc882_3ST_ch6_init[] = {
7410	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7411	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7412	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7413	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7414	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7415	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7416	{ } /* end */
7417};
7418
7419static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7420	{ 2, alc882_3ST_ch2_init },
7421	{ 4, alc882_3ST_ch4_init },
7422	{ 6, alc882_3ST_ch6_init },
7423};
7424
7425#define alc883_3ST_6ch_modes	alc882_3ST_6ch_modes
7426
7427/*
7428 * 2ch mode
7429 */
7430static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7431	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7432	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7433	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7434	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7435	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7436	{ } /* end */
7437};
7438
7439/*
7440 * 4ch mode
7441 */
7442static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7443	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7444	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7445	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7446	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7447	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7448	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7449	{ } /* end */
7450};
7451
7452/*
7453 * 6ch mode
7454 */
7455static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7456	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7457	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7458	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7459	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7460	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7461	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7462	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7463	{ } /* end */
7464};
7465
7466static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7467	{ 2, alc883_3ST_ch2_clevo_init },
7468	{ 4, alc883_3ST_ch4_clevo_init },
7469	{ 6, alc883_3ST_ch6_clevo_init },
7470};
7471
7472
7473/*
7474 * 6ch mode
7475 */
7476static struct hda_verb alc882_sixstack_ch6_init[] = {
7477	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7478	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7479	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7480	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7481	{ } /* end */
7482};
7483
7484/*
7485 * 8ch mode
7486 */
7487static struct hda_verb alc882_sixstack_ch8_init[] = {
7488	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7489	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7490	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7491	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7492	{ } /* end */
7493};
7494
7495static struct hda_channel_mode alc882_sixstack_modes[2] = {
7496	{ 6, alc882_sixstack_ch6_init },
7497	{ 8, alc882_sixstack_ch8_init },
7498};
7499
7500
7501/* Macbook Air 2,1 */
7502
7503static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7504      { 2, NULL },
7505};
7506
7507/*
7508 * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7509 */
7510
7511/*
7512 * 2ch mode
7513 */
7514static struct hda_verb alc885_mbp_ch2_init[] = {
7515	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7516	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7517	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7518	{ } /* end */
7519};
7520
7521/*
7522 * 4ch mode
7523 */
7524static struct hda_verb alc885_mbp_ch4_init[] = {
7525	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7526	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7527	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7528	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7529	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7530	{ } /* end */
7531};
7532
7533static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7534	{ 2, alc885_mbp_ch2_init },
7535	{ 4, alc885_mbp_ch4_init },
7536};
7537
7538/*
7539 * 2ch
7540 * Speakers/Woofer/HP = Front
7541 * LineIn = Input
7542 */
7543static struct hda_verb alc885_mb5_ch2_init[] = {
7544	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7545	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7546	{ } /* end */
7547};
7548
7549/*
7550 * 6ch mode
7551 * Speakers/HP = Front
7552 * Woofer = LFE
7553 * LineIn = Surround
7554 */
7555static struct hda_verb alc885_mb5_ch6_init[] = {
7556	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7557	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7558	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7559	{ } /* end */
7560};
7561
7562static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7563	{ 2, alc885_mb5_ch2_init },
7564	{ 6, alc885_mb5_ch6_init },
7565};
7566
7567#define alc885_macmini3_6ch_modes	alc885_mb5_6ch_modes
7568
7569/*
7570 * 2ch mode
7571 */
7572static struct hda_verb alc883_4ST_ch2_init[] = {
7573	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7574	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7575	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7576	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7577	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7578	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7579	{ } /* end */
7580};
7581
7582/*
7583 * 4ch mode
7584 */
7585static struct hda_verb alc883_4ST_ch4_init[] = {
7586	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7587	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7588	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7589	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7590	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7591	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7592	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7593	{ } /* end */
7594};
7595
7596/*
7597 * 6ch mode
7598 */
7599static struct hda_verb alc883_4ST_ch6_init[] = {
7600	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7601	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7602	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7603	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7604	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7605	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7606	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7607	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7608	{ } /* end */
7609};
7610
7611/*
7612 * 8ch mode
7613 */
7614static struct hda_verb alc883_4ST_ch8_init[] = {
7615	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7616	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7617	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7618	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7619	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7620	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7621	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7622	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7623	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7624	{ } /* end */
7625};
7626
7627static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7628	{ 2, alc883_4ST_ch2_init },
7629	{ 4, alc883_4ST_ch4_init },
7630	{ 6, alc883_4ST_ch6_init },
7631	{ 8, alc883_4ST_ch8_init },
7632};
7633
7634
7635/*
7636 * 2ch mode
7637 */
7638static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7639	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7640	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7641	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7642	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7643	{ } /* end */
7644};
7645
7646/*
7647 * 4ch mode
7648 */
7649static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7650	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7651	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7652	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7653	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7654	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7655	{ } /* end */
7656};
7657
7658/*
7659 * 6ch mode
7660 */
7661static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7662	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7663	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7664	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7665	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7666	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7667	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7668	{ } /* end */
7669};
7670
7671static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7672	{ 2, alc883_3ST_ch2_intel_init },
7673	{ 4, alc883_3ST_ch4_intel_init },
7674	{ 6, alc883_3ST_ch6_intel_init },
7675};
7676
7677/*
7678 * 2ch mode
7679 */
7680static struct hda_verb alc889_ch2_intel_init[] = {
7681	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7682	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7683	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7684	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7685	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7686	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7687	{ } /* end */
7688};
7689
7690/*
7691 * 6ch mode
7692 */
7693static struct hda_verb alc889_ch6_intel_init[] = {
7694	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7695	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7696	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7697	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7698	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7699	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7700	{ } /* end */
7701};
7702
7703/*
7704 * 8ch mode
7705 */
7706static struct hda_verb alc889_ch8_intel_init[] = {
7707	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7708	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7709	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7710	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7711	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7712	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7713	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7714	{ } /* end */
7715};
7716
7717static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7718	{ 2, alc889_ch2_intel_init },
7719	{ 6, alc889_ch6_intel_init },
7720	{ 8, alc889_ch8_intel_init },
7721};
7722
7723/*
7724 * 6ch mode
7725 */
7726static struct hda_verb alc883_sixstack_ch6_init[] = {
7727	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7728	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7729	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7730	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7731	{ } /* end */
7732};
7733
7734/*
7735 * 8ch mode
7736 */
7737static struct hda_verb alc883_sixstack_ch8_init[] = {
7738	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7739	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7740	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7741	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7742	{ } /* end */
7743};
7744
7745static struct hda_channel_mode alc883_sixstack_modes[2] = {
7746	{ 6, alc883_sixstack_ch6_init },
7747	{ 8, alc883_sixstack_ch8_init },
7748};
7749
7750
7751/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7752 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7753 */
7754static struct snd_kcontrol_new alc882_base_mixer[] = {
7755	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7756	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7757	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7758	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7759	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7760	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7761	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7762	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7763	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7764	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7765	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7766	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7767	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7768	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7769	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7770	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7771	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7772	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7773	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7774	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7775	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7776	{ } /* end */
7777};
7778
7779/* Macbook Air 2,1 same control for HP and internal Speaker */
7780
7781static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7782      HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7783      HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7784     { }
7785};
7786
7787
7788static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7789	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7790	HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7791	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7792	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7793	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7794	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7795	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7796	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7797	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7798	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7799	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7800	{ } /* end */
7801};
7802
7803static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7804	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7805	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7806	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7807	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7808	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7809	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7810	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7811	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7812	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7813	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7814	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7815	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7816	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7817	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7818	{ } /* end */
7819};
7820
7821static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7822	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7823	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7824	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7825	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7826	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7827	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7828	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7829	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7830	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7831	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7832	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7833	{ } /* end */
7834};
7835
7836static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7837	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7838	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7839	{ } /* end */
7840};
7841
7842
7843static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7844	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7845	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7846	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7847	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7848	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7849	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7850	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7851	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7852	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7853	{ } /* end */
7854};
7855
7856static struct snd_kcontrol_new alc882_targa_mixer[] = {
7857	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7858	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7859	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7860	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7861	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7862	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7863	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7864	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7865	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7866	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7867	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7868	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7869	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7870	{ } /* end */
7871};
7872
7873/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7874 *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7875 */
7876static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7877	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7878	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7879	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7880	HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7881	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7882	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7883	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7884	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7885	HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7886	HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7887	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7888	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7889	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7890	{ } /* end */
7891};
7892
7893static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7894	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7895	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7896	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7897	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7898	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7899	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7900	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7901	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7902	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7903	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7904	{ } /* end */
7905};
7906
7907static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7908	{
7909		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7910		.name = "Channel Mode",
7911		.info = alc_ch_mode_info,
7912		.get = alc_ch_mode_get,
7913		.put = alc_ch_mode_put,
7914	},
7915	{ } /* end */
7916};
7917
7918static struct hda_verb alc882_base_init_verbs[] = {
7919	/* Front mixer: unmute input/output amp left and right (volume = 0) */
7920	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7921	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7922	/* Rear mixer */
7923	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7924	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7925	/* CLFE mixer */
7926	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7927	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7928	/* Side mixer */
7929	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7930	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7931
7932	/* Front Pin: output 0 (0x0c) */
7933	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7934	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7935	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7936	/* Rear Pin: output 1 (0x0d) */
7937	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7938	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7939	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7940	/* CLFE Pin: output 2 (0x0e) */
7941	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7942	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7943	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7944	/* Side Pin: output 3 (0x0f) */
7945	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7946	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7947	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7948	/* Mic (rear) pin: input vref at 80% */
7949	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7950	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7951	/* Front Mic pin: input vref at 80% */
7952	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7953	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7954	/* Line In pin: input */
7955	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7956	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7957	/* Line-2 In: Headphone output (output 0 - 0x0c) */
7958	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7959	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7960	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7961	/* CD pin widget for input */
7962	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7963
7964	/* FIXME: use matrix-type input source selection */
7965	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7966	/* Input mixer2 */
7967	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7968	/* Input mixer3 */
7969	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7970	/* ADC2: mute amp left and right */
7971	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7972	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7973	/* ADC3: mute amp left and right */
7974	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7975	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7976
7977	{ }
7978};
7979
7980static struct hda_verb alc882_adc1_init_verbs[] = {
7981	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7982	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7983	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7984	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7985	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7986	/* ADC1: mute amp left and right */
7987	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7988	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7989	{ }
7990};
7991
7992static struct hda_verb alc882_eapd_verbs[] = {
7993	/* change to EAPD mode */
7994	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7995	{0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7996	{ }
7997};
7998
7999static struct hda_verb alc889_eapd_verbs[] = {
8000	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8001	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8002	{ }
8003};
8004
8005static struct hda_verb alc_hp15_unsol_verbs[] = {
8006	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8007	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8008	{}
8009};
8010
8011static struct hda_verb alc885_init_verbs[] = {
8012	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8013	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8014	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8015	/* Rear mixer */
8016	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8017	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8018	/* CLFE mixer */
8019	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8020	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8021	/* Side mixer */
8022	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8023	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8024
8025	/* Front HP Pin: output 0 (0x0c) */
8026	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8027	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8028	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8029	/* Front Pin: output 0 (0x0c) */
8030	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8031	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8032	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8033	/* Rear Pin: output 1 (0x0d) */
8034	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8035	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8036	{0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8037	/* CLFE Pin: output 2 (0x0e) */
8038	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8039	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8040	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8041	/* Side Pin: output 3 (0x0f) */
8042	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8043	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8044	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8045	/* Mic (rear) pin: input vref at 80% */
8046	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8047	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8048	/* Front Mic pin: input vref at 80% */
8049	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8050	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8051	/* Line In pin: input */
8052	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8053	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8054
8055	/* Mixer elements: 0x18, , 0x1a, 0x1b */
8056	/* Input mixer1 */
8057	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8058	/* Input mixer2 */
8059	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8060	/* Input mixer3 */
8061	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8062	/* ADC2: mute amp left and right */
8063	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8064	/* ADC3: mute amp left and right */
8065	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8066
8067	{ }
8068};
8069
8070static struct hda_verb alc885_init_input_verbs[] = {
8071	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8072	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8073	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8074	{ }
8075};
8076
8077
8078/* Unmute Selector 24h and set the default input to front mic */
8079static struct hda_verb alc889_init_input_verbs[] = {
8080	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8081	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8082	{ }
8083};
8084
8085
8086#define alc883_init_verbs	alc882_base_init_verbs
8087
8088/* Mac Pro test */
8089static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8090	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8091	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8092	HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8093	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8094	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8095	/* FIXME: this looks suspicious...
8096	HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8097	HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8098	*/
8099	{ } /* end */
8100};
8101
8102static struct hda_verb alc882_macpro_init_verbs[] = {
8103	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8104	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8105	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8106	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8107	/* Front Pin: output 0 (0x0c) */
8108	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8109	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8110	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8111	/* Front Mic pin: input vref at 80% */
8112	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8113	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8114	/* Speaker:  output */
8115	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8116	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8117	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8118	/* Headphone output (output 0 - 0x0c) */
8119	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8120	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8121	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8122
8123	/* FIXME: use matrix-type input source selection */
8124	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8125	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8126	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8127	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8128	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8129	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8130	/* Input mixer2 */
8131	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8132	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8133	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8134	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8135	/* Input mixer3 */
8136	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8137	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8138	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8139	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8140	/* ADC1: mute amp left and right */
8141	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8142	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8143	/* ADC2: mute amp left and right */
8144	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8145	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8146	/* ADC3: mute amp left and right */
8147	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8148	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8149
8150	{ }
8151};
8152
8153/* Macbook 5,1 */
8154static struct hda_verb alc885_mb5_init_verbs[] = {
8155	/* DACs */
8156	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8157	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8158	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8159	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8160	/* Front mixer */
8161	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8162	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8163	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8164	/* Surround mixer */
8165	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8166	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8167	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8168	/* LFE mixer */
8169	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8170	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8171	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8172	/* HP mixer */
8173	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8174	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8175	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8176	/* Front Pin (0x0c) */
8177	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8178	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8179	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8180	/* LFE Pin (0x0e) */
8181	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8182	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8183	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8184	/* HP Pin (0x0f) */
8185	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8186	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8187	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8188	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8189	/* Front Mic pin: input vref at 80% */
8190	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8191	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8192	/* Line In pin */
8193	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8194	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8195
8196	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8197	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8198	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8199	{ }
8200};
8201
8202/* Macmini 3,1 */
8203static struct hda_verb alc885_macmini3_init_verbs[] = {
8204	/* DACs */
8205	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8206	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8207	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8208	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8209	/* Front mixer */
8210	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8211	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8212	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8213	/* Surround mixer */
8214	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8215	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8216	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8217	/* LFE mixer */
8218	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8219	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8220	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8221	/* HP mixer */
8222	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8223	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8224	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8225	/* Front Pin (0x0c) */
8226	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8227	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8228	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8229	/* LFE Pin (0x0e) */
8230	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8231	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8232	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8233	/* HP Pin (0x0f) */
8234	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8235	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8236	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8237	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8238	/* Line In pin */
8239	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8240	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8241
8242	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8243	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8244	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8245	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8246	{ }
8247};
8248
8249
8250static struct hda_verb alc885_mba21_init_verbs[] = {
8251	/*Internal and HP Speaker Mixer*/
8252	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8253	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8254	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8255	/*Internal Speaker Pin (0x0c)*/
8256	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8257	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8258	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8259	/* HP Pin: output 0 (0x0e) */
8260	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8261	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8262	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8263	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8264	/* Line in (is hp when jack connected)*/
8265	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8266	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8267
8268	{ }
8269 };
8270
8271
8272/* Macbook Pro rev3 */
8273static struct hda_verb alc885_mbp3_init_verbs[] = {
8274	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8275	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8276	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8277	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8278	/* Rear mixer */
8279	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8280	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8281	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8282	/* HP mixer */
8283	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8284	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8285	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8286	/* Front Pin: output 0 (0x0c) */
8287	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8288	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8289	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8290	/* HP Pin: output 0 (0x0e) */
8291	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8292	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8293	{0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8294	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8295	/* Mic (rear) pin: input vref at 80% */
8296	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8297	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8298	/* Front Mic pin: input vref at 80% */
8299	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8300	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8301	/* Line In pin: use output 1 when in LineOut mode */
8302	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8303	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8304	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8305
8306	/* FIXME: use matrix-type input source selection */
8307	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8308	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8309	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8310	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8311	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8312	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8313	/* Input mixer2 */
8314	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8315	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8316	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8317	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8318	/* Input mixer3 */
8319	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8320	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8321	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8322	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8323	/* ADC1: mute amp left and right */
8324	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8325	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8326	/* ADC2: mute amp left and right */
8327	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8328	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8329	/* ADC3: mute amp left and right */
8330	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8331	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8332
8333	{ }
8334};
8335
8336/* iMac 9,1 */
8337static struct hda_verb alc885_imac91_init_verbs[] = {
8338	/* Internal Speaker Pin (0x0c) */
8339	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8340	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8341	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8342	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8343	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8344	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8345	/* HP Pin: Rear */
8346	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8347	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8348	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8349	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8350	/* Line in Rear */
8351	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8352	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8353	/* Front Mic pin: input vref at 80% */
8354	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8355	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8356	/* Rear mixer */
8357	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8358	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8359	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8360	/* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8361	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8362	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8363	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8364	/* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8365	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8366	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8367	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8368	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8369	/* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8370	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8371	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8372	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8373	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8374	/* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8375	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8376	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8377	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8378	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8379	/* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8380	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8381	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8382	/* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8383	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8384	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8385	/* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8386	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8387	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8388	{ }
8389};
8390
8391/* iMac 24 mixer. */
8392static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8393	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8394	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8395	{ } /* end */
8396};
8397
8398/* iMac 24 init verbs. */
8399static struct hda_verb alc885_imac24_init_verbs[] = {
8400	/* Internal speakers: output 0 (0x0c) */
8401	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8402	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8403	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8404	/* Internal speakers: output 0 (0x0c) */
8405	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8406	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8407	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8408	/* Headphone: output 0 (0x0c) */
8409	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8410	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8411	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8412	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8413	/* Front Mic: input vref at 80% */
8414	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8415	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8416	{ }
8417};
8418
8419/* Toggle speaker-output according to the hp-jack state */
8420static void alc885_imac24_setup(struct hda_codec *codec)
8421{
8422	struct alc_spec *spec = codec->spec;
8423
8424	spec->autocfg.hp_pins[0] = 0x14;
8425	spec->autocfg.speaker_pins[0] = 0x18;
8426	spec->autocfg.speaker_pins[1] = 0x1a;
8427}
8428
8429#define alc885_mb5_setup	alc885_imac24_setup
8430#define alc885_macmini3_setup	alc885_imac24_setup
8431
8432/* Macbook Air 2,1 */
8433static void alc885_mba21_setup(struct hda_codec *codec)
8434{
8435       struct alc_spec *spec = codec->spec;
8436
8437       spec->autocfg.hp_pins[0] = 0x14;
8438       spec->autocfg.speaker_pins[0] = 0x18;
8439}
8440
8441
8442
8443static void alc885_mbp3_setup(struct hda_codec *codec)
8444{
8445	struct alc_spec *spec = codec->spec;
8446
8447	spec->autocfg.hp_pins[0] = 0x15;
8448	spec->autocfg.speaker_pins[0] = 0x14;
8449}
8450
8451static void alc885_imac91_setup(struct hda_codec *codec)
8452{
8453	struct alc_spec *spec = codec->spec;
8454
8455	spec->autocfg.hp_pins[0] = 0x14;
8456	spec->autocfg.speaker_pins[0] = 0x18;
8457	spec->autocfg.speaker_pins[1] = 0x1a;
8458}
8459
8460static struct hda_verb alc882_targa_verbs[] = {
8461	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8462	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8463
8464	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8465	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8466
8467	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8468	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8469	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8470
8471	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8472	{ } /* end */
8473};
8474
8475/* toggle speaker-output according to the hp-jack state */
8476static void alc882_targa_automute(struct hda_codec *codec)
8477{
8478	struct alc_spec *spec = codec->spec;
8479	alc_automute_amp(codec);
8480	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8481				  spec->jack_present ? 1 : 3);
8482}
8483
8484static void alc882_targa_setup(struct hda_codec *codec)
8485{
8486	struct alc_spec *spec = codec->spec;
8487
8488	spec->autocfg.hp_pins[0] = 0x14;
8489	spec->autocfg.speaker_pins[0] = 0x1b;
8490}
8491
8492static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8493{
8494	if ((res >> 26) == ALC880_HP_EVENT)
8495		alc882_targa_automute(codec);
8496}
8497
8498static struct hda_verb alc882_asus_a7j_verbs[] = {
8499	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8500	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8501
8502	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8503	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8504	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8505
8506	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8507	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8508	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8509
8510	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8511	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8512	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8513	{ } /* end */
8514};
8515
8516static struct hda_verb alc882_asus_a7m_verbs[] = {
8517	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8518	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8519
8520	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8521	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8522	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8523
8524	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8525	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8526	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8527
8528	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8529	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8530	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8531 	{ } /* end */
8532};
8533
8534static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8535{
8536	unsigned int gpiostate, gpiomask, gpiodir;
8537
8538	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8539				       AC_VERB_GET_GPIO_DATA, 0);
8540
8541	if (!muted)
8542		gpiostate |= (1 << pin);
8543	else
8544		gpiostate &= ~(1 << pin);
8545
8546	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8547				      AC_VERB_GET_GPIO_MASK, 0);
8548	gpiomask |= (1 << pin);
8549
8550	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8551				     AC_VERB_GET_GPIO_DIRECTION, 0);
8552	gpiodir |= (1 << pin);
8553
8554
8555	snd_hda_codec_write(codec, codec->afg, 0,
8556			    AC_VERB_SET_GPIO_MASK, gpiomask);
8557	snd_hda_codec_write(codec, codec->afg, 0,
8558			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8559
8560	msleep(1);
8561
8562	snd_hda_codec_write(codec, codec->afg, 0,
8563			    AC_VERB_SET_GPIO_DATA, gpiostate);
8564}
8565
8566/* set up GPIO at initialization */
8567static void alc885_macpro_init_hook(struct hda_codec *codec)
8568{
8569	alc882_gpio_mute(codec, 0, 0);
8570	alc882_gpio_mute(codec, 1, 0);
8571}
8572
8573/* set up GPIO and update auto-muting at initialization */
8574static void alc885_imac24_init_hook(struct hda_codec *codec)
8575{
8576	alc885_macpro_init_hook(codec);
8577	alc_automute_amp(codec);
8578}
8579
8580/*
8581 * generic initialization of ADC, input mixers and output mixers
8582 */
8583static struct hda_verb alc883_auto_init_verbs[] = {
8584	/*
8585	 * Unmute ADC0-2 and set the default input to mic-in
8586	 */
8587	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8588	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8589	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8590	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8591
8592	/*
8593	 * Set up output mixers (0x0c - 0x0f)
8594	 */
8595	/* set vol=0 to output mixers */
8596	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8597	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8598	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8599	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8600	/* set up input amps for analog loopback */
8601	/* Amp Indices: DAC = 0, mixer = 1 */
8602	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8603	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8604	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8605	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8606	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8607	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8608	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8609	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8610	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8611	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8612
8613	/* FIXME: use matrix-type input source selection */
8614	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8615	/* Input mixer2 */
8616	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8617	/* Input mixer3 */
8618	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8619	{ }
8620};
8621
8622/* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8623static struct hda_verb alc889A_mb31_ch2_init[] = {
8624	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8625	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8626	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8627	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8628	{ } /* end */
8629};
8630
8631/* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8632static struct hda_verb alc889A_mb31_ch4_init[] = {
8633	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8634	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8635	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8636	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8637	{ } /* end */
8638};
8639
8640/* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8641static struct hda_verb alc889A_mb31_ch5_init[] = {
8642	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8643	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8644	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8645	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8646	{ } /* end */
8647};
8648
8649/* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8650static struct hda_verb alc889A_mb31_ch6_init[] = {
8651	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8652	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8653	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8654	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8655	{ } /* end */
8656};
8657
8658static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8659	{ 2, alc889A_mb31_ch2_init },
8660	{ 4, alc889A_mb31_ch4_init },
8661	{ 5, alc889A_mb31_ch5_init },
8662	{ 6, alc889A_mb31_ch6_init },
8663};
8664
8665static struct hda_verb alc883_medion_eapd_verbs[] = {
8666        /* eanable EAPD on medion laptop */
8667	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8668	{0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8669	{ }
8670};
8671
8672#define alc883_base_mixer	alc882_base_mixer
8673
8674static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8675	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8676	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8677	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8678	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8679	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8680	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8681	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8682	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8683	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8684	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8685	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8686	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8687	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8688	{ } /* end */
8689};
8690
8691static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8692	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8693	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8694	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8695	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8696	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8697	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8698	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8699	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8700	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8701	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8702	{ } /* end */
8703};
8704
8705static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8706	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8707	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8708	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8709	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8710	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8711	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8712	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8713	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8714	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8715	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8716	{ } /* end */
8717};
8718
8719static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8720	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8721	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8722	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8723	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8724	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8725	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8726	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8727	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8728	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8729	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8730	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8731	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8732	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8733	{ } /* end */
8734};
8735
8736static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8737	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8738	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8739	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8740	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8741	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8742	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8743	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8744	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8745	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8746	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8747	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8748	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8749	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8750	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8751	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8752	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8753	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8754	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8755	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8756	{ } /* end */
8757};
8758
8759static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8760	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8761	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8762	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8763	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8764	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8765			      HDA_OUTPUT),
8766	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8767	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8768	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8769	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8770	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8771	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8772	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8773	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8774	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8775	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8776	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8777	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8778	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8779	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8780	{ } /* end */
8781};
8782
8783static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8784	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8785	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8786	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8787	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8788	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8789			      HDA_OUTPUT),
8790	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8791	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8792	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8793	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8794	HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8795	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8796	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8797	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8798	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8799	HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8800	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8801	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8802	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8803	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8804	{ } /* end */
8805};
8806
8807static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8808	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8809	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8810	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8811	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8812	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8813	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8814	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8815	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8816	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8817	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8818	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8819	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8820	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8821	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8822	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8823	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8824	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8825	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8826	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8827	{ } /* end */
8828};
8829
8830static struct snd_kcontrol_new alc883_targa_mixer[] = {
8831	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8832	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8833	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8834	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8835	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8836	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8837	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8838	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8839	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8840	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8841	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8842	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8843	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8844	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8845	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8846	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8847	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8848	{ } /* end */
8849};
8850
8851static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8852	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8853	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8854	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8855	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8856	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8857	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8858	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8859	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8860	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8861	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8862	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8863	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8864	{ } /* end */
8865};
8866
8867static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8868	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8869	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8870	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8871	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8872	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8873	{ } /* end */
8874};
8875
8876static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8877	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8878	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8879	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8880	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8881	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8882	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8883	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8884	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8885	{ } /* end */
8886};
8887
8888static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8889	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8890	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8891	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8892	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8893	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8894	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8895	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8896	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8897	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8898	{ } /* end */
8899};
8900
8901static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8902	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8903	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8904	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8905	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8906	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8907	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8908	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8909	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8910	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8911	{ } /* end */
8912};
8913
8914static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
8915	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8916	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8917	HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8918	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
8919	HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
8920	HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
8921	{ } /* end */
8922};
8923
8924static struct hda_verb alc883_medion_wim2160_verbs[] = {
8925	/* Unmute front mixer */
8926	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8927	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8928
8929	/* Set speaker pin to front mixer */
8930	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8931
8932	/* Init headphone pin */
8933	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8934	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8935	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8936	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8937
8938	{ } /* end */
8939};
8940
8941/* toggle speaker-output according to the hp-jack state */
8942static void alc883_medion_wim2160_setup(struct hda_codec *codec)
8943{
8944	struct alc_spec *spec = codec->spec;
8945
8946	spec->autocfg.hp_pins[0] = 0x1a;
8947	spec->autocfg.speaker_pins[0] = 0x15;
8948}
8949
8950static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8951	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8952	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8953	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8954	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8955	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8956	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8957	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8958	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8959	{ } /* end */
8960};
8961
8962static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8963	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8964	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8965	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8966	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8967	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8968	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8969	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8970	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8971	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8972	{ } /* end */
8973};
8974
8975static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8976	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8977	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8978	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8979	HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8980	HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8981						0x0d, 1, 0x0, HDA_OUTPUT),
8982	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8983	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8984	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8985	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8986	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8987	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8988	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8989	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8990	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8991	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8992	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8993	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8994	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8995	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8996	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8997	{ } /* end */
8998};
8999
9000static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9001	/* Output mixers */
9002	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9003	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9004	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9005	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9006	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9007		HDA_OUTPUT),
9008	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9009	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9010	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9011	/* Output switches */
9012	HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9013	HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9014	HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9015	/* Boost mixers */
9016	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
9017	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
9018	/* Input mixers */
9019	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9020	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9021	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9022	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9023	{ } /* end */
9024};
9025
9026static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9027	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9028	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9029	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9030	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9031	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9032	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9033	{ } /* end */
9034};
9035
9036static struct hda_bind_ctls alc883_bind_cap_vol = {
9037	.ops = &snd_hda_bind_vol,
9038	.values = {
9039		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9040		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9041		0
9042	},
9043};
9044
9045static struct hda_bind_ctls alc883_bind_cap_switch = {
9046	.ops = &snd_hda_bind_sw,
9047	.values = {
9048		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9049		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9050		0
9051	},
9052};
9053
9054static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9055	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9056	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9057	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9058	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9059	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9060	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9061	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9062	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9063	{ } /* end */
9064};
9065
9066static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9067	HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9068	HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9069	{
9070		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9071		/* .name = "Capture Source", */
9072		.name = "Input Source",
9073		.count = 1,
9074		.info = alc_mux_enum_info,
9075		.get = alc_mux_enum_get,
9076		.put = alc_mux_enum_put,
9077	},
9078	{ } /* end */
9079};
9080
9081static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9082	{
9083		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9084		.name = "Channel Mode",
9085		.info = alc_ch_mode_info,
9086		.get = alc_ch_mode_get,
9087		.put = alc_ch_mode_put,
9088	},
9089	{ } /* end */
9090};
9091
9092/* toggle speaker-output according to the hp-jack state */
9093static void alc883_mitac_setup(struct hda_codec *codec)
9094{
9095	struct alc_spec *spec = codec->spec;
9096
9097	spec->autocfg.hp_pins[0] = 0x15;
9098	spec->autocfg.speaker_pins[0] = 0x14;
9099	spec->autocfg.speaker_pins[1] = 0x17;
9100}
9101
9102/* auto-toggle front mic */
9103/*
9104static void alc883_mitac_mic_automute(struct hda_codec *codec)
9105{
9106	unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
9107
9108	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
9109}
9110*/
9111
9112static struct hda_verb alc883_mitac_verbs[] = {
9113	/* HP */
9114	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9115	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9116	/* Subwoofer */
9117	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9118	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9119
9120	/* enable unsolicited event */
9121	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9122	/* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9123
9124	{ } /* end */
9125};
9126
9127static struct hda_verb alc883_clevo_m540r_verbs[] = {
9128	/* HP */
9129	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9130	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9131	/* Int speaker */
9132	/*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9133
9134	/* enable unsolicited event */
9135	/*
9136	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9137	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9138	*/
9139
9140	{ } /* end */
9141};
9142
9143static struct hda_verb alc883_clevo_m720_verbs[] = {
9144	/* HP */
9145	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9146	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9147	/* Int speaker */
9148	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9149	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9150
9151	/* enable unsolicited event */
9152	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9153	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9154
9155	{ } /* end */
9156};
9157
9158static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9159	/* HP */
9160	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9161	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9162	/* Subwoofer */
9163	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9164	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9165
9166	/* enable unsolicited event */
9167	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9168
9169	{ } /* end */
9170};
9171
9172static struct hda_verb alc883_targa_verbs[] = {
9173	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9174	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9175
9176	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9177	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9178
9179/* Connect Line-Out side jack (SPDIF) to Side */
9180	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9181	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9182	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9183/* Connect Mic jack to CLFE */
9184	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9185	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9186	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9187/* Connect Line-in jack to Surround */
9188	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9189	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9190	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9191/* Connect HP out jack to Front */
9192	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9193	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9194	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9195
9196	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9197
9198	{ } /* end */
9199};
9200
9201static struct hda_verb alc883_lenovo_101e_verbs[] = {
9202	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9203	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9204        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9205	{ } /* end */
9206};
9207
9208static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9209        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9210	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9211        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9212        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9213	{ } /* end */
9214};
9215
9216static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9217	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9218	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9219	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9220	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9221	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9222	{ } /* end */
9223};
9224
9225static struct hda_verb alc883_haier_w66_verbs[] = {
9226	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9227	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9228
9229	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9230
9231	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9232	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9233	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9234	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9235	{ } /* end */
9236};
9237
9238static struct hda_verb alc888_lenovo_sky_verbs[] = {
9239	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9240	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9241	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9242	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9243	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9244	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9245	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9246	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9247	{ } /* end */
9248};
9249
9250static struct hda_verb alc888_6st_dell_verbs[] = {
9251	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9252	{ }
9253};
9254
9255static struct hda_verb alc883_vaiott_verbs[] = {
9256	/* HP */
9257	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9258	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9259
9260	/* enable unsolicited event */
9261	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9262
9263	{ } /* end */
9264};
9265
9266static void alc888_3st_hp_setup(struct hda_codec *codec)
9267{
9268	struct alc_spec *spec = codec->spec;
9269
9270	spec->autocfg.hp_pins[0] = 0x1b;
9271	spec->autocfg.speaker_pins[0] = 0x14;
9272	spec->autocfg.speaker_pins[1] = 0x16;
9273	spec->autocfg.speaker_pins[2] = 0x18;
9274}
9275
9276static struct hda_verb alc888_3st_hp_verbs[] = {
9277	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Front: output 0 (0x0c) */
9278	{0x16, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Rear : output 1 (0x0d) */
9279	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},	/* CLFE : output 2 (0x0e) */
9280	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9281	{ } /* end */
9282};
9283
9284/*
9285 * 2ch mode
9286 */
9287static struct hda_verb alc888_3st_hp_2ch_init[] = {
9288	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9289	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9290	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9291	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9292	{ } /* end */
9293};
9294
9295/*
9296 * 4ch mode
9297 */
9298static struct hda_verb alc888_3st_hp_4ch_init[] = {
9299	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9300	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9301	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9302	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9303	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9304	{ } /* end */
9305};
9306
9307/*
9308 * 6ch mode
9309 */
9310static struct hda_verb alc888_3st_hp_6ch_init[] = {
9311	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9312	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9313	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9314	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9315	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9316	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9317	{ } /* end */
9318};
9319
9320static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9321	{ 2, alc888_3st_hp_2ch_init },
9322	{ 4, alc888_3st_hp_4ch_init },
9323	{ 6, alc888_3st_hp_6ch_init },
9324};
9325
9326/* toggle front-jack and RCA according to the hp-jack state */
9327static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9328{
9329 	unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9330
9331	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9332				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9333	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9334				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9335}
9336
9337/* toggle RCA according to the front-jack state */
9338static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9339{
9340 	unsigned int present = snd_hda_jack_detect(codec, 0x14);
9341
9342	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9343				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9344}
9345
9346static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9347					     unsigned int res)
9348{
9349	if ((res >> 26) == ALC880_HP_EVENT)
9350		alc888_lenovo_ms7195_front_automute(codec);
9351	if ((res >> 26) == ALC880_FRONT_EVENT)
9352		alc888_lenovo_ms7195_rca_automute(codec);
9353}
9354
9355static struct hda_verb alc883_medion_md2_verbs[] = {
9356	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9357	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9358
9359	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9360
9361	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9362	{ } /* end */
9363};
9364
9365/* toggle speaker-output according to the hp-jack state */
9366static void alc883_medion_md2_setup(struct hda_codec *codec)
9367{
9368	struct alc_spec *spec = codec->spec;
9369
9370	spec->autocfg.hp_pins[0] = 0x14;
9371	spec->autocfg.speaker_pins[0] = 0x15;
9372}
9373
9374/* toggle speaker-output according to the hp-jack state */
9375#define alc883_targa_init_hook		alc882_targa_init_hook
9376#define alc883_targa_unsol_event	alc882_targa_unsol_event
9377
9378static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
9379{
9380	unsigned int present;
9381
9382	present = snd_hda_jack_detect(codec, 0x18);
9383	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
9384				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9385}
9386
9387static void alc883_clevo_m720_setup(struct hda_codec *codec)
9388{
9389	struct alc_spec *spec = codec->spec;
9390
9391	spec->autocfg.hp_pins[0] = 0x15;
9392	spec->autocfg.speaker_pins[0] = 0x14;
9393}
9394
9395static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9396{
9397	alc_automute_amp(codec);
9398	alc883_clevo_m720_mic_automute(codec);
9399}
9400
9401static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9402					   unsigned int res)
9403{
9404	switch (res >> 26) {
9405	case ALC880_MIC_EVENT:
9406		alc883_clevo_m720_mic_automute(codec);
9407		break;
9408	default:
9409		alc_automute_amp_unsol_event(codec, res);
9410		break;
9411	}
9412}
9413
9414/* toggle speaker-output according to the hp-jack state */
9415static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9416{
9417	struct alc_spec *spec = codec->spec;
9418
9419	spec->autocfg.hp_pins[0] = 0x14;
9420	spec->autocfg.speaker_pins[0] = 0x15;
9421}
9422
9423static void alc883_haier_w66_setup(struct hda_codec *codec)
9424{
9425	struct alc_spec *spec = codec->spec;
9426
9427	spec->autocfg.hp_pins[0] = 0x1b;
9428	spec->autocfg.speaker_pins[0] = 0x14;
9429}
9430
9431static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9432{
9433	int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9434
9435	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9436				 HDA_AMP_MUTE, bits);
9437}
9438
9439static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9440{
9441	int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9442
9443	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9444				 HDA_AMP_MUTE, bits);
9445	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9446				 HDA_AMP_MUTE, bits);
9447}
9448
9449static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9450					   unsigned int res)
9451{
9452	if ((res >> 26) == ALC880_HP_EVENT)
9453		alc883_lenovo_101e_all_automute(codec);
9454	if ((res >> 26) == ALC880_FRONT_EVENT)
9455		alc883_lenovo_101e_ispeaker_automute(codec);
9456}
9457
9458/* toggle speaker-output according to the hp-jack state */
9459static void alc883_acer_aspire_setup(struct hda_codec *codec)
9460{
9461	struct alc_spec *spec = codec->spec;
9462
9463	spec->autocfg.hp_pins[0] = 0x14;
9464	spec->autocfg.speaker_pins[0] = 0x15;
9465	spec->autocfg.speaker_pins[1] = 0x16;
9466}
9467
9468static struct hda_verb alc883_acer_eapd_verbs[] = {
9469	/* HP Pin: output 0 (0x0c) */
9470	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9471	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9472	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9473	/* Front Pin: output 0 (0x0c) */
9474	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9475	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9476	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9477	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9478        /* eanable EAPD on medion laptop */
9479	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9480	{0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9481	/* enable unsolicited event */
9482	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9483	{ }
9484};
9485
9486static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
9487	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9488	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9489	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9490	{ } /* end */
9491};
9492
9493static void alc888_6st_dell_setup(struct hda_codec *codec)
9494{
9495	struct alc_spec *spec = codec->spec;
9496
9497	spec->autocfg.hp_pins[0] = 0x1b;
9498	spec->autocfg.speaker_pins[0] = 0x14;
9499	spec->autocfg.speaker_pins[1] = 0x15;
9500	spec->autocfg.speaker_pins[2] = 0x16;
9501	spec->autocfg.speaker_pins[3] = 0x17;
9502}
9503
9504static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9505{
9506	struct alc_spec *spec = codec->spec;
9507
9508	spec->autocfg.hp_pins[0] = 0x1b;
9509	spec->autocfg.speaker_pins[0] = 0x14;
9510	spec->autocfg.speaker_pins[1] = 0x15;
9511	spec->autocfg.speaker_pins[2] = 0x16;
9512	spec->autocfg.speaker_pins[3] = 0x17;
9513	spec->autocfg.speaker_pins[4] = 0x1a;
9514}
9515
9516static void alc883_vaiott_setup(struct hda_codec *codec)
9517{
9518	struct alc_spec *spec = codec->spec;
9519
9520	spec->autocfg.hp_pins[0] = 0x15;
9521	spec->autocfg.speaker_pins[0] = 0x14;
9522	spec->autocfg.speaker_pins[1] = 0x17;
9523}
9524
9525static struct hda_verb alc888_asus_m90v_verbs[] = {
9526	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9527	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9528	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9529	/* enable unsolicited event */
9530	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9531	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9532	{ } /* end */
9533};
9534
9535static void alc883_mode2_setup(struct hda_codec *codec)
9536{
9537	struct alc_spec *spec = codec->spec;
9538
9539	spec->autocfg.hp_pins[0] = 0x1b;
9540	spec->autocfg.speaker_pins[0] = 0x14;
9541	spec->autocfg.speaker_pins[1] = 0x15;
9542	spec->autocfg.speaker_pins[2] = 0x16;
9543	spec->ext_mic.pin = 0x18;
9544	spec->int_mic.pin = 0x19;
9545	spec->ext_mic.mux_idx = 0;
9546	spec->int_mic.mux_idx = 1;
9547	spec->auto_mic = 1;
9548}
9549
9550static struct hda_verb alc888_asus_eee1601_verbs[] = {
9551	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9552	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9553	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9554	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9555	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9556	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9557	{0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9558	/* enable unsolicited event */
9559	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9560	{ } /* end */
9561};
9562
9563static void alc883_eee1601_inithook(struct hda_codec *codec)
9564{
9565	struct alc_spec *spec = codec->spec;
9566
9567	spec->autocfg.hp_pins[0] = 0x14;
9568	spec->autocfg.speaker_pins[0] = 0x1b;
9569	alc_automute_pin(codec);
9570}
9571
9572static struct hda_verb alc889A_mb31_verbs[] = {
9573	/* Init rear pin (used as headphone output) */
9574	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9575	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9576	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9577	/* Init line pin (used as output in 4ch and 6ch mode) */
9578	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9579	/* Init line 2 pin (used as headphone out by default) */
9580	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9581	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9582	{ } /* end */
9583};
9584
9585/* Mute speakers according to the headphone jack state */
9586static void alc889A_mb31_automute(struct hda_codec *codec)
9587{
9588	unsigned int present;
9589
9590	/* Mute only in 2ch or 4ch mode */
9591	if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9592	    == 0x00) {
9593		present = snd_hda_jack_detect(codec, 0x15);
9594		snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9595			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9596		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9597			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9598	}
9599}
9600
9601static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9602{
9603	if ((res >> 26) == ALC880_HP_EVENT)
9604		alc889A_mb31_automute(codec);
9605}
9606
9607
9608#ifdef CONFIG_SND_HDA_POWER_SAVE
9609#define alc882_loopbacks	alc880_loopbacks
9610#endif
9611
9612/* pcm configuration: identical with ALC880 */
9613#define alc882_pcm_analog_playback	alc880_pcm_analog_playback
9614#define alc882_pcm_analog_capture	alc880_pcm_analog_capture
9615#define alc882_pcm_digital_playback	alc880_pcm_digital_playback
9616#define alc882_pcm_digital_capture	alc880_pcm_digital_capture
9617
9618static hda_nid_t alc883_slave_dig_outs[] = {
9619	ALC1200_DIGOUT_NID, 0,
9620};
9621
9622static hda_nid_t alc1200_slave_dig_outs[] = {
9623	ALC883_DIGOUT_NID, 0,
9624};
9625
9626/*
9627 * configuration and preset
9628 */
9629static const char *alc882_models[ALC882_MODEL_LAST] = {
9630	[ALC882_3ST_DIG]	= "3stack-dig",
9631	[ALC882_6ST_DIG]	= "6stack-dig",
9632	[ALC882_ARIMA]		= "arima",
9633	[ALC882_W2JC]		= "w2jc",
9634	[ALC882_TARGA]		= "targa",
9635	[ALC882_ASUS_A7J]	= "asus-a7j",
9636	[ALC882_ASUS_A7M]	= "asus-a7m",
9637	[ALC885_MACPRO]		= "macpro",
9638	[ALC885_MB5]		= "mb5",
9639	[ALC885_MACMINI3]	= "macmini3",
9640	[ALC885_MBA21]		= "mba21",
9641	[ALC885_MBP3]		= "mbp3",
9642	[ALC885_IMAC24]		= "imac24",
9643	[ALC885_IMAC91]		= "imac91",
9644	[ALC883_3ST_2ch_DIG]	= "3stack-2ch-dig",
9645	[ALC883_3ST_6ch_DIG]	= "3stack-6ch-dig",
9646	[ALC883_3ST_6ch]	= "3stack-6ch",
9647	[ALC883_6ST_DIG]	= "alc883-6stack-dig",
9648	[ALC883_TARGA_DIG]	= "targa-dig",
9649	[ALC883_TARGA_2ch_DIG]	= "targa-2ch-dig",
9650	[ALC883_TARGA_8ch_DIG]	= "targa-8ch-dig",
9651	[ALC883_ACER]		= "acer",
9652	[ALC883_ACER_ASPIRE]	= "acer-aspire",
9653	[ALC888_ACER_ASPIRE_4930G]	= "acer-aspire-4930g",
9654	[ALC888_ACER_ASPIRE_6530G]	= "acer-aspire-6530g",
9655	[ALC888_ACER_ASPIRE_8930G]	= "acer-aspire-8930g",
9656	[ALC888_ACER_ASPIRE_7730G]	= "acer-aspire-7730g",
9657	[ALC883_MEDION]		= "medion",
9658	[ALC883_MEDION_MD2]	= "medion-md2",
9659	[ALC883_MEDION_WIM2160]	= "medion-wim2160",
9660	[ALC883_LAPTOP_EAPD]	= "laptop-eapd",
9661	[ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9662	[ALC883_LENOVO_NB0763]	= "lenovo-nb0763",
9663	[ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9664	[ALC888_LENOVO_SKY] = "lenovo-sky",
9665	[ALC883_HAIER_W66] 	= "haier-w66",
9666	[ALC888_3ST_HP]		= "3stack-hp",
9667	[ALC888_6ST_DELL]	= "6stack-dell",
9668	[ALC883_MITAC]		= "mitac",
9669	[ALC883_CLEVO_M540R]	= "clevo-m540r",
9670	[ALC883_CLEVO_M720]	= "clevo-m720",
9671	[ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9672	[ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9673	[ALC883_3ST_6ch_INTEL]	= "3stack-6ch-intel",
9674	[ALC889A_INTEL]		= "intel-alc889a",
9675	[ALC889_INTEL]		= "intel-x58",
9676	[ALC1200_ASUS_P5Q]	= "asus-p5q",
9677	[ALC889A_MB31]		= "mb31",
9678	[ALC883_SONY_VAIO_TT]	= "sony-vaio-tt",
9679	[ALC882_AUTO]		= "auto",
9680};
9681
9682static struct snd_pci_quirk alc882_cfg_tbl[] = {
9683	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9684
9685	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9686	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9687	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9688	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9689	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9690	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9691	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9692		ALC888_ACER_ASPIRE_4930G),
9693	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9694		ALC888_ACER_ASPIRE_4930G),
9695	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9696		ALC888_ACER_ASPIRE_8930G),
9697	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9698		ALC888_ACER_ASPIRE_8930G),
9699	SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9700	SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9701	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9702		ALC888_ACER_ASPIRE_6530G),
9703	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9704		ALC888_ACER_ASPIRE_6530G),
9705	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9706		ALC888_ACER_ASPIRE_7730G),
9707	/* default Acer -- disabled as it causes more problems.
9708	 *    model=auto should work fine now
9709	 */
9710	/* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9711
9712	SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9713
9714	SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9715	SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9716	SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9717	SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9718	SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9719	SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9720
9721	SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9722	SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9723	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9724	SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9725	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9726	SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9727	SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9728	SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9729	SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9730	SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9731	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9732
9733	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9734	SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9735	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9736	SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9737	SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9738	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9739	SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9740	SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9741	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9742
9743	SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9744	SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9745	SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9746	SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9747	SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9748	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9749	SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9750	SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9751	SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9752	SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9753	SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9754	SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9755	SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9756	SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9757	SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9758	SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9759	SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9760	SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9761	SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9762	SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9763	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9764	SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9765	SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9766	SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9767	SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9768	SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9769	SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9770	SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9771	SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9772	SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9773	SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9774
9775	SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9776	SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9777	SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9778	SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9779	SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9780	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9781	SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9782	/* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9783	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9784	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9785		      ALC883_FUJITSU_PI2515),
9786	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9787		ALC888_FUJITSU_XA3530),
9788	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9789	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9790	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9791	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9792	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9793	SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9794	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9795	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9796	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9797
9798	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9799	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9800	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9801	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9802	SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9803	SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9804	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9805
9806	{}
9807};
9808
9809/* codec SSID table for Intel Mac */
9810static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9811	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9812	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9813	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9814	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9815	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9816	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9817	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9818	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9819	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9820	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9821	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9822	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9823	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9824	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9825	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9826	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9827	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9828	/* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9829	 * so apparently no perfect solution yet
9830	 */
9831	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9832	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9833	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9834	{} /* terminator */
9835};
9836
9837static struct alc_config_preset alc882_presets[] = {
9838	[ALC882_3ST_DIG] = {
9839		.mixers = { alc882_base_mixer },
9840		.init_verbs = { alc882_base_init_verbs,
9841				alc882_adc1_init_verbs },
9842		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9843		.dac_nids = alc882_dac_nids,
9844		.dig_out_nid = ALC882_DIGOUT_NID,
9845		.dig_in_nid = ALC882_DIGIN_NID,
9846		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9847		.channel_mode = alc882_ch_modes,
9848		.need_dac_fix = 1,
9849		.input_mux = &alc882_capture_source,
9850	},
9851	[ALC882_6ST_DIG] = {
9852		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9853		.init_verbs = { alc882_base_init_verbs,
9854				alc882_adc1_init_verbs },
9855		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9856		.dac_nids = alc882_dac_nids,
9857		.dig_out_nid = ALC882_DIGOUT_NID,
9858		.dig_in_nid = ALC882_DIGIN_NID,
9859		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9860		.channel_mode = alc882_sixstack_modes,
9861		.input_mux = &alc882_capture_source,
9862	},
9863	[ALC882_ARIMA] = {
9864		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9865		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9866				alc882_eapd_verbs },
9867		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9868		.dac_nids = alc882_dac_nids,
9869		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9870		.channel_mode = alc882_sixstack_modes,
9871		.input_mux = &alc882_capture_source,
9872	},
9873	[ALC882_W2JC] = {
9874		.mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9875		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9876				alc882_eapd_verbs, alc880_gpio1_init_verbs },
9877		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9878		.dac_nids = alc882_dac_nids,
9879		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9880		.channel_mode = alc880_threestack_modes,
9881		.need_dac_fix = 1,
9882		.input_mux = &alc882_capture_source,
9883		.dig_out_nid = ALC882_DIGOUT_NID,
9884	},
9885	   [ALC885_MBA21] = {
9886			.mixers = { alc885_mba21_mixer },
9887			.init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9888			.num_dacs = 2,
9889			.dac_nids = alc882_dac_nids,
9890			.channel_mode = alc885_mba21_ch_modes,
9891			.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9892			.input_mux = &alc882_capture_source,
9893			.unsol_event = alc_automute_amp_unsol_event,
9894			.setup = alc885_mba21_setup,
9895			.init_hook = alc_automute_amp,
9896       },
9897	[ALC885_MBP3] = {
9898		.mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9899		.init_verbs = { alc885_mbp3_init_verbs,
9900				alc880_gpio1_init_verbs },
9901		.num_dacs = 2,
9902		.dac_nids = alc882_dac_nids,
9903		.hp_nid = 0x04,
9904		.channel_mode = alc885_mbp_4ch_modes,
9905		.num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9906		.input_mux = &alc882_capture_source,
9907		.dig_out_nid = ALC882_DIGOUT_NID,
9908		.dig_in_nid = ALC882_DIGIN_NID,
9909		.unsol_event = alc_automute_amp_unsol_event,
9910		.setup = alc885_mbp3_setup,
9911		.init_hook = alc_automute_amp,
9912	},
9913	[ALC885_MB5] = {
9914		.mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9915		.init_verbs = { alc885_mb5_init_verbs,
9916				alc880_gpio1_init_verbs },
9917		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9918		.dac_nids = alc882_dac_nids,
9919		.channel_mode = alc885_mb5_6ch_modes,
9920		.num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9921		.input_mux = &mb5_capture_source,
9922		.dig_out_nid = ALC882_DIGOUT_NID,
9923		.dig_in_nid = ALC882_DIGIN_NID,
9924		.unsol_event = alc_automute_amp_unsol_event,
9925		.setup = alc885_mb5_setup,
9926		.init_hook = alc_automute_amp,
9927	},
9928	[ALC885_MACMINI3] = {
9929		.mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9930		.init_verbs = { alc885_macmini3_init_verbs,
9931				alc880_gpio1_init_verbs },
9932		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9933		.dac_nids = alc882_dac_nids,
9934		.channel_mode = alc885_macmini3_6ch_modes,
9935		.num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9936		.input_mux = &macmini3_capture_source,
9937		.dig_out_nid = ALC882_DIGOUT_NID,
9938		.dig_in_nid = ALC882_DIGIN_NID,
9939		.unsol_event = alc_automute_amp_unsol_event,
9940		.setup = alc885_macmini3_setup,
9941		.init_hook = alc_automute_amp,
9942	},
9943	[ALC885_MACPRO] = {
9944		.mixers = { alc882_macpro_mixer },
9945		.init_verbs = { alc882_macpro_init_verbs },
9946		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9947		.dac_nids = alc882_dac_nids,
9948		.dig_out_nid = ALC882_DIGOUT_NID,
9949		.dig_in_nid = ALC882_DIGIN_NID,
9950		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9951		.channel_mode = alc882_ch_modes,
9952		.input_mux = &alc882_capture_source,
9953		.init_hook = alc885_macpro_init_hook,
9954	},
9955	[ALC885_IMAC24] = {
9956		.mixers = { alc885_imac24_mixer },
9957		.init_verbs = { alc885_imac24_init_verbs },
9958		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9959		.dac_nids = alc882_dac_nids,
9960		.dig_out_nid = ALC882_DIGOUT_NID,
9961		.dig_in_nid = ALC882_DIGIN_NID,
9962		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9963		.channel_mode = alc882_ch_modes,
9964		.input_mux = &alc882_capture_source,
9965		.unsol_event = alc_automute_amp_unsol_event,
9966		.setup = alc885_imac24_setup,
9967		.init_hook = alc885_imac24_init_hook,
9968	},
9969	[ALC885_IMAC91] = {
9970		.mixers = {alc885_imac91_mixer},
9971		.init_verbs = { alc885_imac91_init_verbs,
9972				alc880_gpio1_init_verbs },
9973		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9974		.dac_nids = alc882_dac_nids,
9975		.channel_mode = alc885_mba21_ch_modes,
9976		.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9977		.input_mux = &alc889A_imac91_capture_source,
9978		.dig_out_nid = ALC882_DIGOUT_NID,
9979		.dig_in_nid = ALC882_DIGIN_NID,
9980		.unsol_event = alc_automute_amp_unsol_event,
9981		.setup = alc885_imac91_setup,
9982		.init_hook = alc_automute_amp,
9983	},
9984	[ALC882_TARGA] = {
9985		.mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9986		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9987				alc880_gpio3_init_verbs, alc882_targa_verbs},
9988		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9989		.dac_nids = alc882_dac_nids,
9990		.dig_out_nid = ALC882_DIGOUT_NID,
9991		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9992		.adc_nids = alc882_adc_nids,
9993		.capsrc_nids = alc882_capsrc_nids,
9994		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9995		.channel_mode = alc882_3ST_6ch_modes,
9996		.need_dac_fix = 1,
9997		.input_mux = &alc882_capture_source,
9998		.unsol_event = alc882_targa_unsol_event,
9999		.setup = alc882_targa_setup,
10000		.init_hook = alc882_targa_automute,
10001	},
10002	[ALC882_ASUS_A7J] = {
10003		.mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10004		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10005				alc882_asus_a7j_verbs},
10006		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10007		.dac_nids = alc882_dac_nids,
10008		.dig_out_nid = ALC882_DIGOUT_NID,
10009		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10010		.adc_nids = alc882_adc_nids,
10011		.capsrc_nids = alc882_capsrc_nids,
10012		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10013		.channel_mode = alc882_3ST_6ch_modes,
10014		.need_dac_fix = 1,
10015		.input_mux = &alc882_capture_source,
10016	},
10017	[ALC882_ASUS_A7M] = {
10018		.mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10019		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10020				alc882_eapd_verbs, alc880_gpio1_init_verbs,
10021				alc882_asus_a7m_verbs },
10022		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10023		.dac_nids = alc882_dac_nids,
10024		.dig_out_nid = ALC882_DIGOUT_NID,
10025		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10026		.channel_mode = alc880_threestack_modes,
10027		.need_dac_fix = 1,
10028		.input_mux = &alc882_capture_source,
10029	},
10030	[ALC883_3ST_2ch_DIG] = {
10031		.mixers = { alc883_3ST_2ch_mixer },
10032		.init_verbs = { alc883_init_verbs },
10033		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10034		.dac_nids = alc883_dac_nids,
10035		.dig_out_nid = ALC883_DIGOUT_NID,
10036		.dig_in_nid = ALC883_DIGIN_NID,
10037		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10038		.channel_mode = alc883_3ST_2ch_modes,
10039		.input_mux = &alc883_capture_source,
10040	},
10041	[ALC883_3ST_6ch_DIG] = {
10042		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10043		.init_verbs = { alc883_init_verbs },
10044		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10045		.dac_nids = alc883_dac_nids,
10046		.dig_out_nid = ALC883_DIGOUT_NID,
10047		.dig_in_nid = ALC883_DIGIN_NID,
10048		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10049		.channel_mode = alc883_3ST_6ch_modes,
10050		.need_dac_fix = 1,
10051		.input_mux = &alc883_capture_source,
10052	},
10053	[ALC883_3ST_6ch] = {
10054		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10055		.init_verbs = { alc883_init_verbs },
10056		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10057		.dac_nids = alc883_dac_nids,
10058		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10059		.channel_mode = alc883_3ST_6ch_modes,
10060		.need_dac_fix = 1,
10061		.input_mux = &alc883_capture_source,
10062	},
10063	[ALC883_3ST_6ch_INTEL] = {
10064		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10065		.init_verbs = { alc883_init_verbs },
10066		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10067		.dac_nids = alc883_dac_nids,
10068		.dig_out_nid = ALC883_DIGOUT_NID,
10069		.dig_in_nid = ALC883_DIGIN_NID,
10070		.slave_dig_outs = alc883_slave_dig_outs,
10071		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10072		.channel_mode = alc883_3ST_6ch_intel_modes,
10073		.need_dac_fix = 1,
10074		.input_mux = &alc883_3stack_6ch_intel,
10075	},
10076	[ALC889A_INTEL] = {
10077		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10078		.init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10079				alc_hp15_unsol_verbs },
10080		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10081		.dac_nids = alc883_dac_nids,
10082		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10083		.adc_nids = alc889_adc_nids,
10084		.dig_out_nid = ALC883_DIGOUT_NID,
10085		.dig_in_nid = ALC883_DIGIN_NID,
10086		.slave_dig_outs = alc883_slave_dig_outs,
10087		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10088		.channel_mode = alc889_8ch_intel_modes,
10089		.capsrc_nids = alc889_capsrc_nids,
10090		.input_mux = &alc889_capture_source,
10091		.setup = alc889_automute_setup,
10092		.init_hook = alc_automute_amp,
10093		.unsol_event = alc_automute_amp_unsol_event,
10094		.need_dac_fix = 1,
10095	},
10096	[ALC889_INTEL] = {
10097		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10098		.init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10099				alc889_eapd_verbs, alc_hp15_unsol_verbs},
10100		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10101		.dac_nids = alc883_dac_nids,
10102		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10103		.adc_nids = alc889_adc_nids,
10104		.dig_out_nid = ALC883_DIGOUT_NID,
10105		.dig_in_nid = ALC883_DIGIN_NID,
10106		.slave_dig_outs = alc883_slave_dig_outs,
10107		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10108		.channel_mode = alc889_8ch_intel_modes,
10109		.capsrc_nids = alc889_capsrc_nids,
10110		.input_mux = &alc889_capture_source,
10111		.setup = alc889_automute_setup,
10112		.init_hook = alc889_intel_init_hook,
10113		.unsol_event = alc_automute_amp_unsol_event,
10114		.need_dac_fix = 1,
10115	},
10116	[ALC883_6ST_DIG] = {
10117		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10118		.init_verbs = { alc883_init_verbs },
10119		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10120		.dac_nids = alc883_dac_nids,
10121		.dig_out_nid = ALC883_DIGOUT_NID,
10122		.dig_in_nid = ALC883_DIGIN_NID,
10123		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10124		.channel_mode = alc883_sixstack_modes,
10125		.input_mux = &alc883_capture_source,
10126	},
10127	[ALC883_TARGA_DIG] = {
10128		.mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10129		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10130				alc883_targa_verbs},
10131		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10132		.dac_nids = alc883_dac_nids,
10133		.dig_out_nid = ALC883_DIGOUT_NID,
10134		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10135		.channel_mode = alc883_3ST_6ch_modes,
10136		.need_dac_fix = 1,
10137		.input_mux = &alc883_capture_source,
10138		.unsol_event = alc883_targa_unsol_event,
10139		.setup = alc882_targa_setup,
10140		.init_hook = alc882_targa_automute,
10141	},
10142	[ALC883_TARGA_2ch_DIG] = {
10143		.mixers = { alc883_targa_2ch_mixer},
10144		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10145				alc883_targa_verbs},
10146		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10147		.dac_nids = alc883_dac_nids,
10148		.adc_nids = alc883_adc_nids_alt,
10149		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10150		.capsrc_nids = alc883_capsrc_nids,
10151		.dig_out_nid = ALC883_DIGOUT_NID,
10152		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10153		.channel_mode = alc883_3ST_2ch_modes,
10154		.input_mux = &alc883_capture_source,
10155		.unsol_event = alc883_targa_unsol_event,
10156		.setup = alc882_targa_setup,
10157		.init_hook = alc882_targa_automute,
10158	},
10159	[ALC883_TARGA_8ch_DIG] = {
10160		.mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10161			    alc883_chmode_mixer },
10162		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10163				alc883_targa_verbs },
10164		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10165		.dac_nids = alc883_dac_nids,
10166		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10167		.adc_nids = alc883_adc_nids_rev,
10168		.capsrc_nids = alc883_capsrc_nids_rev,
10169		.dig_out_nid = ALC883_DIGOUT_NID,
10170		.dig_in_nid = ALC883_DIGIN_NID,
10171		.num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10172		.channel_mode = alc883_4ST_8ch_modes,
10173		.need_dac_fix = 1,
10174		.input_mux = &alc883_capture_source,
10175		.unsol_event = alc883_targa_unsol_event,
10176		.setup = alc882_targa_setup,
10177		.init_hook = alc882_targa_automute,
10178	},
10179	[ALC883_ACER] = {
10180		.mixers = { alc883_base_mixer },
10181		/* On TravelMate laptops, GPIO 0 enables the internal speaker
10182		 * and the headphone jack.  Turn this on and rely on the
10183		 * standard mute methods whenever the user wants to turn
10184		 * these outputs off.
10185		 */
10186		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10187		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10188		.dac_nids = alc883_dac_nids,
10189		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10190		.channel_mode = alc883_3ST_2ch_modes,
10191		.input_mux = &alc883_capture_source,
10192	},
10193	[ALC883_ACER_ASPIRE] = {
10194		.mixers = { alc883_acer_aspire_mixer },
10195		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10196		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10197		.dac_nids = alc883_dac_nids,
10198		.dig_out_nid = ALC883_DIGOUT_NID,
10199		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10200		.channel_mode = alc883_3ST_2ch_modes,
10201		.input_mux = &alc883_capture_source,
10202		.unsol_event = alc_automute_amp_unsol_event,
10203		.setup = alc883_acer_aspire_setup,
10204		.init_hook = alc_automute_amp,
10205	},
10206	[ALC888_ACER_ASPIRE_4930G] = {
10207		.mixers = { alc888_base_mixer,
10208				alc883_chmode_mixer },
10209		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10210				alc888_acer_aspire_4930g_verbs },
10211		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10212		.dac_nids = alc883_dac_nids,
10213		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10214		.adc_nids = alc883_adc_nids_rev,
10215		.capsrc_nids = alc883_capsrc_nids_rev,
10216		.dig_out_nid = ALC883_DIGOUT_NID,
10217		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10218		.channel_mode = alc883_3ST_6ch_modes,
10219		.need_dac_fix = 1,
10220		.const_channel_count = 6,
10221		.num_mux_defs =
10222			ARRAY_SIZE(alc888_2_capture_sources),
10223		.input_mux = alc888_2_capture_sources,
10224		.unsol_event = alc_automute_amp_unsol_event,
10225		.setup = alc888_acer_aspire_4930g_setup,
10226		.init_hook = alc_automute_amp,
10227	},
10228	[ALC888_ACER_ASPIRE_6530G] = {
10229		.mixers = { alc888_acer_aspire_6530_mixer },
10230		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10231				alc888_acer_aspire_6530g_verbs },
10232		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10233		.dac_nids = alc883_dac_nids,
10234		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10235		.adc_nids = alc883_adc_nids_rev,
10236		.capsrc_nids = alc883_capsrc_nids_rev,
10237		.dig_out_nid = ALC883_DIGOUT_NID,
10238		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10239		.channel_mode = alc883_3ST_2ch_modes,
10240		.num_mux_defs =
10241			ARRAY_SIZE(alc888_2_capture_sources),
10242		.input_mux = alc888_acer_aspire_6530_sources,
10243		.unsol_event = alc_automute_amp_unsol_event,
10244		.setup = alc888_acer_aspire_6530g_setup,
10245		.init_hook = alc_automute_amp,
10246	},
10247	[ALC888_ACER_ASPIRE_8930G] = {
10248		.mixers = { alc889_acer_aspire_8930g_mixer,
10249				alc883_chmode_mixer },
10250		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10251				alc889_acer_aspire_8930g_verbs,
10252				alc889_eapd_verbs},
10253		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10254		.dac_nids = alc883_dac_nids,
10255		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10256		.adc_nids = alc889_adc_nids,
10257		.capsrc_nids = alc889_capsrc_nids,
10258		.dig_out_nid = ALC883_DIGOUT_NID,
10259		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10260		.channel_mode = alc883_3ST_6ch_modes,
10261		.need_dac_fix = 1,
10262		.const_channel_count = 6,
10263		.num_mux_defs =
10264			ARRAY_SIZE(alc889_capture_sources),
10265		.input_mux = alc889_capture_sources,
10266		.unsol_event = alc_automute_amp_unsol_event,
10267		.setup = alc889_acer_aspire_8930g_setup,
10268		.init_hook = alc_automute_amp,
10269#ifdef CONFIG_SND_HDA_POWER_SAVE
10270		.power_hook = alc_power_eapd,
10271#endif
10272	},
10273	[ALC888_ACER_ASPIRE_7730G] = {
10274		.mixers = { alc883_3ST_6ch_mixer,
10275				alc883_chmode_mixer },
10276		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10277				alc888_acer_aspire_7730G_verbs },
10278		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10279		.dac_nids = alc883_dac_nids,
10280		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10281		.adc_nids = alc883_adc_nids_rev,
10282		.capsrc_nids = alc883_capsrc_nids_rev,
10283		.dig_out_nid = ALC883_DIGOUT_NID,
10284		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10285		.channel_mode = alc883_3ST_6ch_modes,
10286		.need_dac_fix = 1,
10287		.const_channel_count = 6,
10288		.input_mux = &alc883_capture_source,
10289		.unsol_event = alc_automute_amp_unsol_event,
10290		.setup = alc888_acer_aspire_6530g_setup,
10291		.init_hook = alc_automute_amp,
10292	},
10293	[ALC883_MEDION] = {
10294		.mixers = { alc883_fivestack_mixer,
10295			    alc883_chmode_mixer },
10296		.init_verbs = { alc883_init_verbs,
10297				alc883_medion_eapd_verbs },
10298		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10299		.dac_nids = alc883_dac_nids,
10300		.adc_nids = alc883_adc_nids_alt,
10301		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10302		.capsrc_nids = alc883_capsrc_nids,
10303		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10304		.channel_mode = alc883_sixstack_modes,
10305		.input_mux = &alc883_capture_source,
10306	},
10307	[ALC883_MEDION_MD2] = {
10308		.mixers = { alc883_medion_md2_mixer},
10309		.init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
10310		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10311		.dac_nids = alc883_dac_nids,
10312		.dig_out_nid = ALC883_DIGOUT_NID,
10313		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10314		.channel_mode = alc883_3ST_2ch_modes,
10315		.input_mux = &alc883_capture_source,
10316		.unsol_event = alc_automute_amp_unsol_event,
10317		.setup = alc883_medion_md2_setup,
10318		.init_hook = alc_automute_amp,
10319	},
10320	[ALC883_MEDION_WIM2160] = {
10321		.mixers = { alc883_medion_wim2160_mixer },
10322		.init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10323		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10324		.dac_nids = alc883_dac_nids,
10325		.dig_out_nid = ALC883_DIGOUT_NID,
10326		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10327		.adc_nids = alc883_adc_nids,
10328		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10329		.channel_mode = alc883_3ST_2ch_modes,
10330		.input_mux = &alc883_capture_source,
10331		.unsol_event = alc_automute_amp_unsol_event,
10332		.setup = alc883_medion_wim2160_setup,
10333		.init_hook = alc_automute_amp,
10334	},
10335	[ALC883_LAPTOP_EAPD] = {
10336		.mixers = { alc883_base_mixer },
10337		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10338		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10339		.dac_nids = alc883_dac_nids,
10340		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10341		.channel_mode = alc883_3ST_2ch_modes,
10342		.input_mux = &alc883_capture_source,
10343	},
10344	[ALC883_CLEVO_M540R] = {
10345		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10346		.init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10347		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10348		.dac_nids = alc883_dac_nids,
10349		.dig_out_nid = ALC883_DIGOUT_NID,
10350		.dig_in_nid = ALC883_DIGIN_NID,
10351		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10352		.channel_mode = alc883_3ST_6ch_clevo_modes,
10353		.need_dac_fix = 1,
10354		.input_mux = &alc883_capture_source,
10355		/* This machine has the hardware HP auto-muting, thus
10356		 * we need no software mute via unsol event
10357		 */
10358	},
10359	[ALC883_CLEVO_M720] = {
10360		.mixers = { alc883_clevo_m720_mixer },
10361		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10362		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10363		.dac_nids = alc883_dac_nids,
10364		.dig_out_nid = ALC883_DIGOUT_NID,
10365		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10366		.channel_mode = alc883_3ST_2ch_modes,
10367		.input_mux = &alc883_capture_source,
10368		.unsol_event = alc883_clevo_m720_unsol_event,
10369		.setup = alc883_clevo_m720_setup,
10370		.init_hook = alc883_clevo_m720_init_hook,
10371	},
10372	[ALC883_LENOVO_101E_2ch] = {
10373		.mixers = { alc883_lenovo_101e_2ch_mixer},
10374		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10375		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10376		.dac_nids = alc883_dac_nids,
10377		.adc_nids = alc883_adc_nids_alt,
10378		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10379		.capsrc_nids = alc883_capsrc_nids,
10380		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10381		.channel_mode = alc883_3ST_2ch_modes,
10382		.input_mux = &alc883_lenovo_101e_capture_source,
10383		.unsol_event = alc883_lenovo_101e_unsol_event,
10384		.init_hook = alc883_lenovo_101e_all_automute,
10385	},
10386	[ALC883_LENOVO_NB0763] = {
10387		.mixers = { alc883_lenovo_nb0763_mixer },
10388		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10389		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10390		.dac_nids = alc883_dac_nids,
10391		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10392		.channel_mode = alc883_3ST_2ch_modes,
10393		.need_dac_fix = 1,
10394		.input_mux = &alc883_lenovo_nb0763_capture_source,
10395		.unsol_event = alc_automute_amp_unsol_event,
10396		.setup = alc883_medion_md2_setup,
10397		.init_hook = alc_automute_amp,
10398	},
10399	[ALC888_LENOVO_MS7195_DIG] = {
10400		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10401		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10402		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10403		.dac_nids = alc883_dac_nids,
10404		.dig_out_nid = ALC883_DIGOUT_NID,
10405		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10406		.channel_mode = alc883_3ST_6ch_modes,
10407		.need_dac_fix = 1,
10408		.input_mux = &alc883_capture_source,
10409		.unsol_event = alc883_lenovo_ms7195_unsol_event,
10410		.init_hook = alc888_lenovo_ms7195_front_automute,
10411	},
10412	[ALC883_HAIER_W66] = {
10413		.mixers = { alc883_targa_2ch_mixer},
10414		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10415		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10416		.dac_nids = alc883_dac_nids,
10417		.dig_out_nid = ALC883_DIGOUT_NID,
10418		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10419		.channel_mode = alc883_3ST_2ch_modes,
10420		.input_mux = &alc883_capture_source,
10421		.unsol_event = alc_automute_amp_unsol_event,
10422		.setup = alc883_haier_w66_setup,
10423		.init_hook = alc_automute_amp,
10424	},
10425	[ALC888_3ST_HP] = {
10426		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10427		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10428		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10429		.dac_nids = alc883_dac_nids,
10430		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10431		.channel_mode = alc888_3st_hp_modes,
10432		.need_dac_fix = 1,
10433		.input_mux = &alc883_capture_source,
10434		.unsol_event = alc_automute_amp_unsol_event,
10435		.setup = alc888_3st_hp_setup,
10436		.init_hook = alc_automute_amp,
10437	},
10438	[ALC888_6ST_DELL] = {
10439		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10440		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10441		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10442		.dac_nids = alc883_dac_nids,
10443		.dig_out_nid = ALC883_DIGOUT_NID,
10444		.dig_in_nid = ALC883_DIGIN_NID,
10445		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10446		.channel_mode = alc883_sixstack_modes,
10447		.input_mux = &alc883_capture_source,
10448		.unsol_event = alc_automute_amp_unsol_event,
10449		.setup = alc888_6st_dell_setup,
10450		.init_hook = alc_automute_amp,
10451	},
10452	[ALC883_MITAC] = {
10453		.mixers = { alc883_mitac_mixer },
10454		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10455		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10456		.dac_nids = alc883_dac_nids,
10457		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10458		.channel_mode = alc883_3ST_2ch_modes,
10459		.input_mux = &alc883_capture_source,
10460		.unsol_event = alc_automute_amp_unsol_event,
10461		.setup = alc883_mitac_setup,
10462		.init_hook = alc_automute_amp,
10463	},
10464	[ALC883_FUJITSU_PI2515] = {
10465		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10466		.init_verbs = { alc883_init_verbs,
10467				alc883_2ch_fujitsu_pi2515_verbs},
10468		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10469		.dac_nids = alc883_dac_nids,
10470		.dig_out_nid = ALC883_DIGOUT_NID,
10471		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10472		.channel_mode = alc883_3ST_2ch_modes,
10473		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10474		.unsol_event = alc_automute_amp_unsol_event,
10475		.setup = alc883_2ch_fujitsu_pi2515_setup,
10476		.init_hook = alc_automute_amp,
10477	},
10478	[ALC888_FUJITSU_XA3530] = {
10479		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
10480		.init_verbs = { alc883_init_verbs,
10481			alc888_fujitsu_xa3530_verbs },
10482		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10483		.dac_nids = alc883_dac_nids,
10484		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10485		.adc_nids = alc883_adc_nids_rev,
10486		.capsrc_nids = alc883_capsrc_nids_rev,
10487		.dig_out_nid = ALC883_DIGOUT_NID,
10488		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10489		.channel_mode = alc888_4ST_8ch_intel_modes,
10490		.num_mux_defs =
10491			ARRAY_SIZE(alc888_2_capture_sources),
10492		.input_mux = alc888_2_capture_sources,
10493		.unsol_event = alc_automute_amp_unsol_event,
10494		.setup = alc888_fujitsu_xa3530_setup,
10495		.init_hook = alc_automute_amp,
10496	},
10497	[ALC888_LENOVO_SKY] = {
10498		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10499		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10500		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10501		.dac_nids = alc883_dac_nids,
10502		.dig_out_nid = ALC883_DIGOUT_NID,
10503		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10504		.channel_mode = alc883_sixstack_modes,
10505		.need_dac_fix = 1,
10506		.input_mux = &alc883_lenovo_sky_capture_source,
10507		.unsol_event = alc_automute_amp_unsol_event,
10508		.setup = alc888_lenovo_sky_setup,
10509		.init_hook = alc_automute_amp,
10510	},
10511	[ALC888_ASUS_M90V] = {
10512		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10513		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10514		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10515		.dac_nids = alc883_dac_nids,
10516		.dig_out_nid = ALC883_DIGOUT_NID,
10517		.dig_in_nid = ALC883_DIGIN_NID,
10518		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10519		.channel_mode = alc883_3ST_6ch_modes,
10520		.need_dac_fix = 1,
10521		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10522		.unsol_event = alc_sku_unsol_event,
10523		.setup = alc883_mode2_setup,
10524		.init_hook = alc_inithook,
10525	},
10526	[ALC888_ASUS_EEE1601] = {
10527		.mixers = { alc883_asus_eee1601_mixer },
10528		.cap_mixer = alc883_asus_eee1601_cap_mixer,
10529		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10530		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10531		.dac_nids = alc883_dac_nids,
10532		.dig_out_nid = ALC883_DIGOUT_NID,
10533		.dig_in_nid = ALC883_DIGIN_NID,
10534		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10535		.channel_mode = alc883_3ST_2ch_modes,
10536		.need_dac_fix = 1,
10537		.input_mux = &alc883_asus_eee1601_capture_source,
10538		.unsol_event = alc_sku_unsol_event,
10539		.init_hook = alc883_eee1601_inithook,
10540	},
10541	[ALC1200_ASUS_P5Q] = {
10542		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10543		.init_verbs = { alc883_init_verbs },
10544		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10545		.dac_nids = alc883_dac_nids,
10546		.dig_out_nid = ALC1200_DIGOUT_NID,
10547		.dig_in_nid = ALC883_DIGIN_NID,
10548		.slave_dig_outs = alc1200_slave_dig_outs,
10549		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10550		.channel_mode = alc883_sixstack_modes,
10551		.input_mux = &alc883_capture_source,
10552	},
10553	[ALC889A_MB31] = {
10554		.mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10555		.init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10556			alc880_gpio1_init_verbs },
10557		.adc_nids = alc883_adc_nids,
10558		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10559		.capsrc_nids = alc883_capsrc_nids,
10560		.dac_nids = alc883_dac_nids,
10561		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10562		.channel_mode = alc889A_mb31_6ch_modes,
10563		.num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10564		.input_mux = &alc889A_mb31_capture_source,
10565		.dig_out_nid = ALC883_DIGOUT_NID,
10566		.unsol_event = alc889A_mb31_unsol_event,
10567		.init_hook = alc889A_mb31_automute,
10568	},
10569	[ALC883_SONY_VAIO_TT] = {
10570		.mixers = { alc883_vaiott_mixer },
10571		.init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10572		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10573		.dac_nids = alc883_dac_nids,
10574		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10575		.channel_mode = alc883_3ST_2ch_modes,
10576		.input_mux = &alc883_capture_source,
10577		.unsol_event = alc_automute_amp_unsol_event,
10578		.setup = alc883_vaiott_setup,
10579		.init_hook = alc_automute_amp,
10580	},
10581};
10582
10583
10584/*
10585 * Pin config fixes
10586 */
10587enum {
10588	PINFIX_ABIT_AW9D_MAX,
10589	PINFIX_PB_M5210,
10590};
10591
10592static const struct alc_fixup alc882_fixups[] = {
10593	[PINFIX_ABIT_AW9D_MAX] = {
10594		.pins = (const struct alc_pincfg[]) {
10595			{ 0x15, 0x01080104 }, /* side */
10596			{ 0x16, 0x01011012 }, /* rear */
10597			{ 0x17, 0x01016011 }, /* clfe */
10598			{ }
10599		}
10600	},
10601	[PINFIX_PB_M5210] = {
10602		.verbs = (const struct hda_verb[]) {
10603			{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10604			{}
10605		}
10606	},
10607};
10608
10609static struct snd_pci_quirk alc882_fixup_tbl[] = {
10610	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10611	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10612	{}
10613};
10614
10615/*
10616 * BIOS auto configuration
10617 */
10618static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10619						const struct auto_pin_cfg *cfg)
10620{
10621	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10622}
10623
10624static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10625					      hda_nid_t nid, int pin_type,
10626					      hda_nid_t dac)
10627{
10628	int idx;
10629
10630	/* set as output */
10631	alc_set_pin_output(codec, nid, pin_type);
10632
10633	if (dac == 0x25)
10634		idx = 4;
10635	else if (dac >= 0x02 && dac <= 0x05)
10636		idx = dac - 2;
10637	else
10638		return;
10639	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10640}
10641
10642static void alc882_auto_init_multi_out(struct hda_codec *codec)
10643{
10644	struct alc_spec *spec = codec->spec;
10645	int i;
10646
10647	for (i = 0; i <= HDA_SIDE; i++) {
10648		hda_nid_t nid = spec->autocfg.line_out_pins[i];
10649		int pin_type = get_pin_type(spec->autocfg.line_out_type);
10650		if (nid)
10651			alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10652					spec->multiout.dac_nids[i]);
10653	}
10654}
10655
10656static void alc882_auto_init_hp_out(struct hda_codec *codec)
10657{
10658	struct alc_spec *spec = codec->spec;
10659	hda_nid_t pin, dac;
10660	int i;
10661
10662	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10663		pin = spec->autocfg.hp_pins[i];
10664		if (!pin)
10665			break;
10666		dac = spec->multiout.hp_nid;
10667		if (!dac)
10668			dac = spec->multiout.dac_nids[0]; /* to front */
10669		alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10670	}
10671	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10672		pin = spec->autocfg.speaker_pins[i];
10673		if (!pin)
10674			break;
10675		dac = spec->multiout.extra_out_nid[0];
10676		if (!dac)
10677			dac = spec->multiout.dac_nids[0]; /* to front */
10678		alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10679	}
10680}
10681
10682static void alc882_auto_init_analog_input(struct hda_codec *codec)
10683{
10684	struct alc_spec *spec = codec->spec;
10685	struct auto_pin_cfg *cfg = &spec->autocfg;
10686	int i;
10687
10688	for (i = 0; i < cfg->num_inputs; i++) {
10689		hda_nid_t nid = cfg->inputs[i].pin;
10690		alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10691		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10692			snd_hda_codec_write(codec, nid, 0,
10693					    AC_VERB_SET_AMP_GAIN_MUTE,
10694					    AMP_OUT_MUTE);
10695	}
10696}
10697
10698static void alc882_auto_init_input_src(struct hda_codec *codec)
10699{
10700	struct alc_spec *spec = codec->spec;
10701	int c;
10702
10703	for (c = 0; c < spec->num_adc_nids; c++) {
10704		hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10705		hda_nid_t nid = spec->capsrc_nids[c];
10706		unsigned int mux_idx;
10707		const struct hda_input_mux *imux;
10708		int conns, mute, idx, item;
10709
10710		conns = snd_hda_get_connections(codec, nid, conn_list,
10711						ARRAY_SIZE(conn_list));
10712		if (conns < 0)
10713			continue;
10714		mux_idx = c >= spec->num_mux_defs ? 0 : c;
10715		imux = &spec->input_mux[mux_idx];
10716		if (!imux->num_items && mux_idx > 0)
10717			imux = &spec->input_mux[0];
10718		for (idx = 0; idx < conns; idx++) {
10719			/* if the current connection is the selected one,
10720			 * unmute it as default - otherwise mute it
10721			 */
10722			mute = AMP_IN_MUTE(idx);
10723			for (item = 0; item < imux->num_items; item++) {
10724				if (imux->items[item].index == idx) {
10725					if (spec->cur_mux[c] == item)
10726						mute = AMP_IN_UNMUTE(idx);
10727					break;
10728				}
10729			}
10730			/* check if we have a selector or mixer
10731			 * we could check for the widget type instead, but
10732			 * just check for Amp-In presence (in case of mixer
10733			 * without amp-in there is something wrong, this
10734			 * function shouldn't be used or capsrc nid is wrong)
10735			 */
10736			if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10737				snd_hda_codec_write(codec, nid, 0,
10738						    AC_VERB_SET_AMP_GAIN_MUTE,
10739						    mute);
10740			else if (mute != AMP_IN_MUTE(idx))
10741				snd_hda_codec_write(codec, nid, 0,
10742						    AC_VERB_SET_CONNECT_SEL,
10743						    idx);
10744		}
10745	}
10746}
10747
10748/* add mic boosts if needed */
10749static int alc_auto_add_mic_boost(struct hda_codec *codec)
10750{
10751	struct alc_spec *spec = codec->spec;
10752	struct auto_pin_cfg *cfg = &spec->autocfg;
10753	int i, err;
10754	hda_nid_t nid;
10755
10756	for (i = 0; i < cfg->num_inputs; i++) {
10757		if (cfg->inputs[i].type > AUTO_PIN_MIC)
10758			break;
10759		nid = cfg->inputs[i].pin;
10760		if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10761			char label[32];
10762			snprintf(label, sizeof(label), "%s Boost",
10763				 hda_get_autocfg_input_label(codec, cfg, i));
10764			err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0,
10765				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10766			if (err < 0)
10767				return err;
10768		}
10769	}
10770	return 0;
10771}
10772
10773/* almost identical with ALC880 parser... */
10774static int alc882_parse_auto_config(struct hda_codec *codec)
10775{
10776	struct alc_spec *spec = codec->spec;
10777	static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10778	int err;
10779
10780	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10781					   alc882_ignore);
10782	if (err < 0)
10783		return err;
10784	if (!spec->autocfg.line_outs)
10785		return 0; /* can't find valid BIOS pin config */
10786
10787	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10788	if (err < 0)
10789		return err;
10790	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10791	if (err < 0)
10792		return err;
10793	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10794					   "Headphone");
10795	if (err < 0)
10796		return err;
10797	err = alc880_auto_create_extra_out(spec,
10798					   spec->autocfg.speaker_pins[0],
10799					   "Speaker");
10800	if (err < 0)
10801		return err;
10802	err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10803	if (err < 0)
10804		return err;
10805
10806	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10807
10808	alc_auto_parse_digital(codec);
10809
10810	if (spec->kctls.list)
10811		add_mixer(spec, spec->kctls.list);
10812
10813	add_verb(spec, alc883_auto_init_verbs);
10814	/* if ADC 0x07 is available, initialize it, too */
10815	if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10816		add_verb(spec, alc882_adc1_init_verbs);
10817
10818	spec->num_mux_defs = 1;
10819	spec->input_mux = &spec->private_imux[0];
10820
10821	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10822
10823	err = alc_auto_add_mic_boost(codec);
10824	if (err < 0)
10825		return err;
10826
10827	return 1; /* config found */
10828}
10829
10830/* additional initialization for auto-configuration model */
10831static void alc882_auto_init(struct hda_codec *codec)
10832{
10833	struct alc_spec *spec = codec->spec;
10834	alc882_auto_init_multi_out(codec);
10835	alc882_auto_init_hp_out(codec);
10836	alc882_auto_init_analog_input(codec);
10837	alc882_auto_init_input_src(codec);
10838	alc_auto_init_digital(codec);
10839	if (spec->unsol_event)
10840		alc_inithook(codec);
10841}
10842
10843static int patch_alc882(struct hda_codec *codec)
10844{
10845	struct alc_spec *spec;
10846	int err, board_config;
10847
10848	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10849	if (spec == NULL)
10850		return -ENOMEM;
10851
10852	codec->spec = spec;
10853
10854	alc_auto_parse_customize_define(codec);
10855
10856	switch (codec->vendor_id) {
10857	case 0x10ec0882:
10858	case 0x10ec0885:
10859		break;
10860	default:
10861		/* ALC883 and variants */
10862		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10863		break;
10864	}
10865
10866	board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10867						  alc882_models,
10868						  alc882_cfg_tbl);
10869
10870	if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10871		board_config = snd_hda_check_board_codec_sid_config(codec,
10872			ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10873
10874	if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10875		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10876		       codec->chip_name);
10877		board_config = ALC882_AUTO;
10878	}
10879
10880	if (board_config == ALC882_AUTO)
10881		alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10882
10883	if (board_config == ALC882_AUTO) {
10884		/* automatic parse from the BIOS config */
10885		err = alc882_parse_auto_config(codec);
10886		if (err < 0) {
10887			alc_free(codec);
10888			return err;
10889		} else if (!err) {
10890			printk(KERN_INFO
10891			       "hda_codec: Cannot set up configuration "
10892			       "from BIOS.  Using base mode...\n");
10893			board_config = ALC882_3ST_DIG;
10894		}
10895	}
10896
10897	if (has_cdefine_beep(codec)) {
10898		err = snd_hda_attach_beep_device(codec, 0x1);
10899		if (err < 0) {
10900			alc_free(codec);
10901			return err;
10902		}
10903	}
10904
10905	if (board_config != ALC882_AUTO)
10906		setup_preset(codec, &alc882_presets[board_config]);
10907
10908	spec->stream_analog_playback = &alc882_pcm_analog_playback;
10909	spec->stream_analog_capture = &alc882_pcm_analog_capture;
10910	/* FIXME: setup DAC5 */
10911	/*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10912	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10913
10914	spec->stream_digital_playback = &alc882_pcm_digital_playback;
10915	spec->stream_digital_capture = &alc882_pcm_digital_capture;
10916
10917	if (!spec->adc_nids && spec->input_mux) {
10918		int i, j;
10919		spec->num_adc_nids = 0;
10920		for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10921			const struct hda_input_mux *imux = spec->input_mux;
10922			hda_nid_t cap;
10923			hda_nid_t items[16];
10924			hda_nid_t nid = alc882_adc_nids[i];
10925			unsigned int wcap = get_wcaps(codec, nid);
10926			/* get type */
10927			wcap = get_wcaps_type(wcap);
10928			if (wcap != AC_WID_AUD_IN)
10929				continue;
10930			spec->private_adc_nids[spec->num_adc_nids] = nid;
10931			err = snd_hda_get_connections(codec, nid, &cap, 1);
10932			if (err < 0)
10933				continue;
10934			err = snd_hda_get_connections(codec, cap, items,
10935						      ARRAY_SIZE(items));
10936			if (err < 0)
10937				continue;
10938			for (j = 0; j < imux->num_items; j++)
10939				if (imux->items[j].index >= err)
10940					break;
10941			if (j < imux->num_items)
10942				continue;
10943			spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10944			spec->num_adc_nids++;
10945		}
10946		spec->adc_nids = spec->private_adc_nids;
10947		spec->capsrc_nids = spec->private_capsrc_nids;
10948	}
10949
10950	set_capture_mixer(codec);
10951
10952	if (has_cdefine_beep(codec))
10953		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10954
10955	if (board_config == ALC882_AUTO)
10956		alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
10957
10958	spec->vmaster_nid = 0x0c;
10959
10960	codec->patch_ops = alc_patch_ops;
10961	if (board_config == ALC882_AUTO)
10962		spec->init_hook = alc882_auto_init;
10963#ifdef CONFIG_SND_HDA_POWER_SAVE
10964	if (!spec->loopback.amplist)
10965		spec->loopback.amplist = alc882_loopbacks;
10966#endif
10967
10968	return 0;
10969}
10970
10971
10972/*
10973 * ALC262 support
10974 */
10975
10976#define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
10977#define ALC262_DIGIN_NID	ALC880_DIGIN_NID
10978
10979#define alc262_dac_nids		alc260_dac_nids
10980#define alc262_adc_nids		alc882_adc_nids
10981#define alc262_adc_nids_alt	alc882_adc_nids_alt
10982#define alc262_capsrc_nids	alc882_capsrc_nids
10983#define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
10984
10985#define alc262_modes		alc260_modes
10986#define alc262_capture_source	alc882_capture_source
10987
10988static hda_nid_t alc262_dmic_adc_nids[1] = {
10989	/* ADC0 */
10990	0x09
10991};
10992
10993static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10994
10995static struct snd_kcontrol_new alc262_base_mixer[] = {
10996	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10997	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10998	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10999	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11000	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11001	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11002	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11003	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11004	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11005	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11006	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11007	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11008	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11009	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11010	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11011	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11012	{ } /* end */
11013};
11014
11015/* update HP, line and mono-out pins according to the master switch */
11016static void alc262_hp_master_update(struct hda_codec *codec)
11017{
11018	struct alc_spec *spec = codec->spec;
11019	int val = spec->master_sw;
11020
11021	/* HP & line-out */
11022	snd_hda_codec_write_cache(codec, 0x1b, 0,
11023				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11024				  val ? PIN_HP : 0);
11025	snd_hda_codec_write_cache(codec, 0x15, 0,
11026				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11027				  val ? PIN_HP : 0);
11028	/* mono (speaker) depending on the HP jack sense */
11029	val = val && !spec->jack_present;
11030	snd_hda_codec_write_cache(codec, 0x16, 0,
11031				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11032				  val ? PIN_OUT : 0);
11033}
11034
11035static void alc262_hp_bpc_automute(struct hda_codec *codec)
11036{
11037	struct alc_spec *spec = codec->spec;
11038
11039	spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11040	alc262_hp_master_update(codec);
11041}
11042
11043static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11044{
11045	if ((res >> 26) != ALC880_HP_EVENT)
11046		return;
11047	alc262_hp_bpc_automute(codec);
11048}
11049
11050static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11051{
11052	struct alc_spec *spec = codec->spec;
11053
11054	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11055	alc262_hp_master_update(codec);
11056}
11057
11058static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11059					   unsigned int res)
11060{
11061	if ((res >> 26) != ALC880_HP_EVENT)
11062		return;
11063	alc262_hp_wildwest_automute(codec);
11064}
11065
11066#define alc262_hp_master_sw_get		alc260_hp_master_sw_get
11067
11068static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11069				   struct snd_ctl_elem_value *ucontrol)
11070{
11071	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11072	struct alc_spec *spec = codec->spec;
11073	int val = !!*ucontrol->value.integer.value;
11074
11075	if (val == spec->master_sw)
11076		return 0;
11077	spec->master_sw = val;
11078	alc262_hp_master_update(codec);
11079	return 1;
11080}
11081
11082#define ALC262_HP_MASTER_SWITCH					\
11083	{							\
11084		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
11085		.name = "Master Playback Switch",		\
11086		.info = snd_ctl_boolean_mono_info,		\
11087		.get = alc262_hp_master_sw_get,			\
11088		.put = alc262_hp_master_sw_put,			\
11089	}, \
11090	{							\
11091		.iface = NID_MAPPING,				\
11092		.name = "Master Playback Switch",		\
11093		.private_value = 0x15 | (0x16 << 8) | (0x1b << 16),	\
11094	}
11095
11096
11097static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11098	ALC262_HP_MASTER_SWITCH,
11099	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11100	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11101	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11102	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11103			      HDA_OUTPUT),
11104	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11105			    HDA_OUTPUT),
11106	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11107	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11108	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11109	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11110	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11111	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11112	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11113	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11114	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11115	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11116	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11117	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11118	{ } /* end */
11119};
11120
11121static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11122	ALC262_HP_MASTER_SWITCH,
11123	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11124	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11125	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11126	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11127	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11128			      HDA_OUTPUT),
11129	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11130			    HDA_OUTPUT),
11131	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11132	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11133	HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
11134	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11135	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11136	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11137	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11138	{ } /* end */
11139};
11140
11141static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11142	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11143	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11144	HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
11145	{ } /* end */
11146};
11147
11148/* mute/unmute internal speaker according to the hp jack and mute state */
11149static void alc262_hp_t5735_setup(struct hda_codec *codec)
11150{
11151	struct alc_spec *spec = codec->spec;
11152
11153	spec->autocfg.hp_pins[0] = 0x15;
11154	spec->autocfg.speaker_pins[0] = 0x14;
11155}
11156
11157static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11158	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11159	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11160	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11161	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11162	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11163	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11164	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11165	{ } /* end */
11166};
11167
11168static struct hda_verb alc262_hp_t5735_verbs[] = {
11169	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11170	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11171
11172	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11173	{ }
11174};
11175
11176static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11177	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11178	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11179	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11180	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11181	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11182	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11183	{ } /* end */
11184};
11185
11186static struct hda_verb alc262_hp_rp5700_verbs[] = {
11187	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11188	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11189	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11190	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11191	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11192	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11193	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11194	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11195	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11196	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11197	{}
11198};
11199
11200static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11201	.num_items = 1,
11202	.items = {
11203		{ "Line", 0x1 },
11204	},
11205};
11206
11207/* bind hp and internal speaker mute (with plug check) as master switch */
11208static void alc262_hippo_master_update(struct hda_codec *codec)
11209{
11210	struct alc_spec *spec = codec->spec;
11211	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11212	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11213	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11214	unsigned int mute;
11215
11216	/* HP */
11217	mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11218	snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11219				 HDA_AMP_MUTE, mute);
11220	/* mute internal speaker per jack sense */
11221	if (spec->jack_present)
11222		mute = HDA_AMP_MUTE;
11223	if (line_nid)
11224		snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11225					 HDA_AMP_MUTE, mute);
11226	if (speaker_nid && speaker_nid != line_nid)
11227		snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11228					 HDA_AMP_MUTE, mute);
11229}
11230
11231#define alc262_hippo_master_sw_get	alc262_hp_master_sw_get
11232
11233static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11234				      struct snd_ctl_elem_value *ucontrol)
11235{
11236	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11237	struct alc_spec *spec = codec->spec;
11238	int val = !!*ucontrol->value.integer.value;
11239
11240	if (val == spec->master_sw)
11241		return 0;
11242	spec->master_sw = val;
11243	alc262_hippo_master_update(codec);
11244	return 1;
11245}
11246
11247#define ALC262_HIPPO_MASTER_SWITCH				\
11248	{							\
11249		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
11250		.name = "Master Playback Switch",		\
11251		.info = snd_ctl_boolean_mono_info,		\
11252		.get = alc262_hippo_master_sw_get,		\
11253		.put = alc262_hippo_master_sw_put,		\
11254	},							\
11255	{							\
11256		.iface = NID_MAPPING,				\
11257		.name = "Master Playback Switch",		\
11258		.subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11259			     (SUBDEV_SPEAKER(0) << 16), \
11260	}
11261
11262static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11263	ALC262_HIPPO_MASTER_SWITCH,
11264	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11265	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11266	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11267	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11268	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11269	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11270	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11271	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11272	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11273	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11274	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11275	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11276	{ } /* end */
11277};
11278
11279static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11280	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11281	ALC262_HIPPO_MASTER_SWITCH,
11282	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11283	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11284	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11285	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11286	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11287	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11288	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11289	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11290	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11291	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11292	{ } /* end */
11293};
11294
11295/* mute/unmute internal speaker according to the hp jack and mute state */
11296static void alc262_hippo_automute(struct hda_codec *codec)
11297{
11298	struct alc_spec *spec = codec->spec;
11299	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11300
11301	spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11302	alc262_hippo_master_update(codec);
11303}
11304
11305static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11306{
11307	if ((res >> 26) != ALC880_HP_EVENT)
11308		return;
11309	alc262_hippo_automute(codec);
11310}
11311
11312static void alc262_hippo_setup(struct hda_codec *codec)
11313{
11314	struct alc_spec *spec = codec->spec;
11315
11316	spec->autocfg.hp_pins[0] = 0x15;
11317	spec->autocfg.speaker_pins[0] = 0x14;
11318}
11319
11320static void alc262_hippo1_setup(struct hda_codec *codec)
11321{
11322	struct alc_spec *spec = codec->spec;
11323
11324	spec->autocfg.hp_pins[0] = 0x1b;
11325	spec->autocfg.speaker_pins[0] = 0x14;
11326}
11327
11328
11329static struct snd_kcontrol_new alc262_sony_mixer[] = {
11330	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11331	ALC262_HIPPO_MASTER_SWITCH,
11332	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11333	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11334	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11335	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11336	{ } /* end */
11337};
11338
11339static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11340	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11341	ALC262_HIPPO_MASTER_SWITCH,
11342	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11343	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11344	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11345	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11346	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11347	{ } /* end */
11348};
11349
11350static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11351	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11352	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11353	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11354	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11355	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11356	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11357	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11358	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11359	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11360	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11361	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11362	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11363	{ } /* end */
11364};
11365
11366static struct hda_verb alc262_tyan_verbs[] = {
11367	/* Headphone automute */
11368	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11369	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11370	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11371
11372	/* P11 AUX_IN, white 4-pin connector */
11373	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11374	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11375	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11376	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11377
11378	{}
11379};
11380
11381/* unsolicited event for HP jack sensing */
11382static void alc262_tyan_setup(struct hda_codec *codec)
11383{
11384	struct alc_spec *spec = codec->spec;
11385
11386	spec->autocfg.hp_pins[0] = 0x1b;
11387	spec->autocfg.speaker_pins[0] = 0x15;
11388}
11389
11390
11391#define alc262_capture_mixer		alc882_capture_mixer
11392#define alc262_capture_alt_mixer	alc882_capture_alt_mixer
11393
11394/*
11395 * generic initialization of ADC, input mixers and output mixers
11396 */
11397static struct hda_verb alc262_init_verbs[] = {
11398	/*
11399	 * Unmute ADC0-2 and set the default input to mic-in
11400	 */
11401	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11402	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11403	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11404	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11405	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11406	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11407
11408	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11409	 * mixer widget
11410	 * Note: PASD motherboards uses the Line In 2 as the input for
11411	 * front panel mic (mic 2)
11412	 */
11413	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11414	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11415	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11416	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11417	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11418	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11419
11420	/*
11421	 * Set up output mixers (0x0c - 0x0e)
11422	 */
11423	/* set vol=0 to output mixers */
11424	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11425	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11426	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11427	/* set up input amps for analog loopback */
11428	/* Amp Indices: DAC = 0, mixer = 1 */
11429	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11430	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11431	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11432	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11433	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11434	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11435
11436	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11437	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11438	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11439	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11440	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11441	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11442
11443	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11444	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11445	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11446	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11447	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11448
11449	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11450	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11451
11452	/* FIXME: use matrix-type input source selection */
11453	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11454	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11455	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11456	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11457	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11458	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11459	/* Input mixer2 */
11460	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11461	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11462	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11463	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11464	/* Input mixer3 */
11465	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11466	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11467	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11468	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11469
11470	{ }
11471};
11472
11473static struct hda_verb alc262_eapd_verbs[] = {
11474	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11475	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11476	{ }
11477};
11478
11479static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11480	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11481	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11482	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11483
11484	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11485	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11486	{}
11487};
11488
11489static struct hda_verb alc262_sony_unsol_verbs[] = {
11490	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11491	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11492	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
11493
11494	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11495	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11496	{}
11497};
11498
11499static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11500	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11501	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11502	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11503	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11504	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11505	{ } /* end */
11506};
11507
11508static struct hda_verb alc262_toshiba_s06_verbs[] = {
11509	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11510	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11511	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11512	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11513	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11514	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11515	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11516	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11517	{}
11518};
11519
11520static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11521{
11522	struct alc_spec *spec = codec->spec;
11523
11524	spec->autocfg.hp_pins[0] = 0x15;
11525	spec->autocfg.speaker_pins[0] = 0x14;
11526	spec->ext_mic.pin = 0x18;
11527	spec->ext_mic.mux_idx = 0;
11528	spec->int_mic.pin = 0x12;
11529	spec->int_mic.mux_idx = 9;
11530	spec->auto_mic = 1;
11531}
11532
11533/*
11534 * nec model
11535 *  0x15 = headphone
11536 *  0x16 = internal speaker
11537 *  0x18 = external mic
11538 */
11539
11540static struct snd_kcontrol_new alc262_nec_mixer[] = {
11541	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11542	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11543
11544	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11545	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11546	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11547
11548	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11549	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11550	{ } /* end */
11551};
11552
11553static struct hda_verb alc262_nec_verbs[] = {
11554	/* Unmute Speaker */
11555	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11556
11557	/* Headphone */
11558	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11559	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11560
11561	/* External mic to headphone */
11562	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11563	/* External mic to speaker */
11564	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11565	{}
11566};
11567
11568/*
11569 * fujitsu model
11570 *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11571 *  0x1b = port replicator headphone out
11572 */
11573
11574#define ALC_HP_EVENT	0x37
11575
11576static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11577	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11578	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11579	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11580	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11581	{}
11582};
11583
11584static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11585	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11586	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11587	{}
11588};
11589
11590static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11591	/* Front Mic pin: input vref at 50% */
11592	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11593	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11594	{}
11595};
11596
11597static struct hda_input_mux alc262_fujitsu_capture_source = {
11598	.num_items = 3,
11599	.items = {
11600		{ "Mic", 0x0 },
11601		{ "Int Mic", 0x1 },
11602		{ "CD", 0x4 },
11603	},
11604};
11605
11606static struct hda_input_mux alc262_HP_capture_source = {
11607	.num_items = 5,
11608	.items = {
11609		{ "Mic", 0x0 },
11610		{ "Front Mic", 0x1 },
11611		{ "Line", 0x2 },
11612		{ "CD", 0x4 },
11613		{ "AUX IN", 0x6 },
11614	},
11615};
11616
11617static struct hda_input_mux alc262_HP_D7000_capture_source = {
11618	.num_items = 4,
11619	.items = {
11620		{ "Mic", 0x0 },
11621		{ "Front Mic", 0x2 },
11622		{ "Line", 0x1 },
11623		{ "CD", 0x4 },
11624	},
11625};
11626
11627/* mute/unmute internal speaker according to the hp jacks and mute state */
11628static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11629{
11630	struct alc_spec *spec = codec->spec;
11631	unsigned int mute;
11632
11633	if (force || !spec->sense_updated) {
11634		spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11635				     snd_hda_jack_detect(codec, 0x1b);
11636		spec->sense_updated = 1;
11637	}
11638	/* unmute internal speaker only if both HPs are unplugged and
11639	 * master switch is on
11640	 */
11641	if (spec->jack_present)
11642		mute = HDA_AMP_MUTE;
11643	else
11644		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11645	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11646				 HDA_AMP_MUTE, mute);
11647}
11648
11649/* unsolicited event for HP jack sensing */
11650static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11651				       unsigned int res)
11652{
11653	if ((res >> 26) != ALC_HP_EVENT)
11654		return;
11655	alc262_fujitsu_automute(codec, 1);
11656}
11657
11658static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11659{
11660	alc262_fujitsu_automute(codec, 1);
11661}
11662
11663/* bind volumes of both NID 0x0c and 0x0d */
11664static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11665	.ops = &snd_hda_bind_vol,
11666	.values = {
11667		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11668		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11669		0
11670	},
11671};
11672
11673/* mute/unmute internal speaker according to the hp jack and mute state */
11674static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11675{
11676	struct alc_spec *spec = codec->spec;
11677	unsigned int mute;
11678
11679	if (force || !spec->sense_updated) {
11680		spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11681		spec->sense_updated = 1;
11682	}
11683	if (spec->jack_present) {
11684		/* mute internal speaker */
11685		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11686					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11687		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11688					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11689	} else {
11690		/* unmute internal speaker if necessary */
11691		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11692		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11693					 HDA_AMP_MUTE, mute);
11694		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11695					 HDA_AMP_MUTE, mute);
11696	}
11697}
11698
11699/* unsolicited event for HP jack sensing */
11700static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11701				       unsigned int res)
11702{
11703	if ((res >> 26) != ALC_HP_EVENT)
11704		return;
11705	alc262_lenovo_3000_automute(codec, 1);
11706}
11707
11708static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11709				  int dir, int idx, long *valp)
11710{
11711	int i, change = 0;
11712
11713	for (i = 0; i < 2; i++, valp++)
11714		change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11715						   HDA_AMP_MUTE,
11716						   *valp ? 0 : HDA_AMP_MUTE);
11717	return change;
11718}
11719
11720/* bind hp and internal speaker mute (with plug check) */
11721static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11722					 struct snd_ctl_elem_value *ucontrol)
11723{
11724	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11725	long *valp = ucontrol->value.integer.value;
11726	int change;
11727
11728	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11729	change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11730	if (change)
11731		alc262_fujitsu_automute(codec, 0);
11732	return change;
11733}
11734
11735static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11736	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11737	{
11738		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11739		.name = "Master Playback Switch",
11740		.subdevice = HDA_SUBDEV_AMP_FLAG,
11741		.info = snd_hda_mixer_amp_switch_info,
11742		.get = snd_hda_mixer_amp_switch_get,
11743		.put = alc262_fujitsu_master_sw_put,
11744		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11745	},
11746	{
11747		.iface = NID_MAPPING,
11748		.name = "Master Playback Switch",
11749		.private_value = 0x1b,
11750	},
11751	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11752	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11753	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11754	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11755	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11756	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11757	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11758	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11759	{ } /* end */
11760};
11761
11762/* bind hp and internal speaker mute (with plug check) */
11763static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11764					 struct snd_ctl_elem_value *ucontrol)
11765{
11766	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11767	long *valp = ucontrol->value.integer.value;
11768	int change;
11769
11770	change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11771	if (change)
11772		alc262_lenovo_3000_automute(codec, 0);
11773	return change;
11774}
11775
11776static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11777	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11778	{
11779		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11780		.name = "Master Playback Switch",
11781		.subdevice = HDA_SUBDEV_AMP_FLAG,
11782		.info = snd_hda_mixer_amp_switch_info,
11783		.get = snd_hda_mixer_amp_switch_get,
11784		.put = alc262_lenovo_3000_master_sw_put,
11785		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11786	},
11787	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11788	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11789	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11790	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11791	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11792	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11793	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11794	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11795	{ } /* end */
11796};
11797
11798static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11799	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11800	ALC262_HIPPO_MASTER_SWITCH,
11801	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11802	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11803	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11804	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11805	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11806	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11807	{ } /* end */
11808};
11809
11810/* additional init verbs for Benq laptops */
11811static struct hda_verb alc262_EAPD_verbs[] = {
11812	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11813	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11814	{}
11815};
11816
11817static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11818	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11819	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11820
11821	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11822	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11823	{}
11824};
11825
11826/* Samsung Q1 Ultra Vista model setup */
11827static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11828	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11829	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11830	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11831	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11832	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11833	HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11834	{ } /* end */
11835};
11836
11837static struct hda_verb alc262_ultra_verbs[] = {
11838	/* output mixer */
11839	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11840	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11841	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11842	/* speaker */
11843	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11844	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11845	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11846	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11847	/* HP */
11848	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11849	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11850	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11851	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11852	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11853	/* internal mic */
11854	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11855	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11856	/* ADC, choose mic */
11857	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11858	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11859	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11860	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11861	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11862	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11863	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11864	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11865	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11866	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11867	{}
11868};
11869
11870/* mute/unmute internal speaker according to the hp jack and mute state */
11871static void alc262_ultra_automute(struct hda_codec *codec)
11872{
11873	struct alc_spec *spec = codec->spec;
11874	unsigned int mute;
11875
11876	mute = 0;
11877	/* auto-mute only when HP is used as HP */
11878	if (!spec->cur_mux[0]) {
11879		spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11880		if (spec->jack_present)
11881			mute = HDA_AMP_MUTE;
11882	}
11883	/* mute/unmute internal speaker */
11884	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11885				 HDA_AMP_MUTE, mute);
11886	/* mute/unmute HP */
11887	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11888				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11889}
11890
11891/* unsolicited event for HP jack sensing */
11892static void alc262_ultra_unsol_event(struct hda_codec *codec,
11893				       unsigned int res)
11894{
11895	if ((res >> 26) != ALC880_HP_EVENT)
11896		return;
11897	alc262_ultra_automute(codec);
11898}
11899
11900static struct hda_input_mux alc262_ultra_capture_source = {
11901	.num_items = 2,
11902	.items = {
11903		{ "Mic", 0x1 },
11904		{ "Headphone", 0x7 },
11905	},
11906};
11907
11908static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11909				     struct snd_ctl_elem_value *ucontrol)
11910{
11911	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11912	struct alc_spec *spec = codec->spec;
11913	int ret;
11914
11915	ret = alc_mux_enum_put(kcontrol, ucontrol);
11916	if (!ret)
11917		return 0;
11918	/* reprogram the HP pin as mic or HP according to the input source */
11919	snd_hda_codec_write_cache(codec, 0x15, 0,
11920				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11921				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11922	alc262_ultra_automute(codec); /* mute/unmute HP */
11923	return ret;
11924}
11925
11926static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11927	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11928	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11929	{
11930		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11931		.name = "Capture Source",
11932		.info = alc_mux_enum_info,
11933		.get = alc_mux_enum_get,
11934		.put = alc262_ultra_mux_enum_put,
11935	},
11936	{
11937		.iface = NID_MAPPING,
11938		.name = "Capture Source",
11939		.private_value = 0x15,
11940	},
11941	{ } /* end */
11942};
11943
11944/* We use two mixers depending on the output pin; 0x16 is a mono output
11945 * and thus it's bound with a different mixer.
11946 * This function returns which mixer amp should be used.
11947 */
11948static int alc262_check_volbit(hda_nid_t nid)
11949{
11950	if (!nid)
11951		return 0;
11952	else if (nid == 0x16)
11953		return 2;
11954	else
11955		return 1;
11956}
11957
11958static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11959				  const char *pfx, int *vbits, int idx)
11960{
11961	unsigned long val;
11962	int vbit;
11963
11964	vbit = alc262_check_volbit(nid);
11965	if (!vbit)
11966		return 0;
11967	if (*vbits & vbit) /* a volume control for this mixer already there */
11968		return 0;
11969	*vbits |= vbit;
11970	if (vbit == 2)
11971		val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11972	else
11973		val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11974	return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
11975}
11976
11977static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11978				 const char *pfx, int idx)
11979{
11980	unsigned long val;
11981
11982	if (!nid)
11983		return 0;
11984	if (nid == 0x16)
11985		val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11986	else
11987		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11988	return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
11989}
11990
11991/* add playback controls from the parsed DAC table */
11992static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11993					     const struct auto_pin_cfg *cfg)
11994{
11995	const char *pfx;
11996	int vbits;
11997	int i, err;
11998
11999	spec->multiout.num_dacs = 1;	/* only use one dac */
12000	spec->multiout.dac_nids = spec->private_dac_nids;
12001	spec->multiout.dac_nids[0] = 2;
12002
12003	if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
12004		pfx = "Master";
12005	else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12006		pfx = "Speaker";
12007	else if (cfg->line_out_type == AUTO_PIN_HP_OUT)
12008		pfx = "Headphone";
12009	else
12010		pfx = "Front";
12011	for (i = 0; i < 2; i++) {
12012		err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12013		if (err < 0)
12014			return err;
12015		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12016			err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12017						    "Speaker", i);
12018			if (err < 0)
12019				return err;
12020		}
12021		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12022			err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12023						    "Headphone", i);
12024			if (err < 0)
12025				return err;
12026		}
12027	}
12028
12029	vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12030		alc262_check_volbit(cfg->speaker_pins[0]) |
12031		alc262_check_volbit(cfg->hp_pins[0]);
12032	if (vbits == 1 || vbits == 2)
12033		pfx = "Master"; /* only one mixer is used */
12034	vbits = 0;
12035	for (i = 0; i < 2; i++) {
12036		err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12037					     &vbits, i);
12038		if (err < 0)
12039			return err;
12040		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12041			err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12042						     "Speaker", &vbits, i);
12043			if (err < 0)
12044				return err;
12045		}
12046		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12047			err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12048						     "Headphone", &vbits, i);
12049			if (err < 0)
12050				return err;
12051		}
12052	}
12053	return 0;
12054}
12055
12056#define alc262_auto_create_input_ctls \
12057	alc882_auto_create_input_ctls
12058
12059/*
12060 * generic initialization of ADC, input mixers and output mixers
12061 */
12062static struct hda_verb alc262_volume_init_verbs[] = {
12063	/*
12064	 * Unmute ADC0-2 and set the default input to mic-in
12065	 */
12066	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12067	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12068	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12069	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12070	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12071	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12072
12073	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12074	 * mixer widget
12075	 * Note: PASD motherboards uses the Line In 2 as the input for
12076	 * front panel mic (mic 2)
12077	 */
12078	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12079	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12080	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12081	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12082	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12083	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12084
12085	/*
12086	 * Set up output mixers (0x0c - 0x0f)
12087	 */
12088	/* set vol=0 to output mixers */
12089	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12090	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12091	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12092
12093	/* set up input amps for analog loopback */
12094	/* Amp Indices: DAC = 0, mixer = 1 */
12095	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12096	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12097	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12098	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12099	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12100	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12101
12102	/* FIXME: use matrix-type input source selection */
12103	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12104	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12105	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12106	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12107	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12108	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12109	/* Input mixer2 */
12110	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12111	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12112	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12113	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12114	/* Input mixer3 */
12115	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12116	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12117	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12118	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12119
12120	{ }
12121};
12122
12123static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12124	/*
12125	 * Unmute ADC0-2 and set the default input to mic-in
12126	 */
12127	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12128	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12129	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12130	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12131	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12132	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12133
12134	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12135	 * mixer widget
12136	 * Note: PASD motherboards uses the Line In 2 as the input for
12137	 * front panel mic (mic 2)
12138	 */
12139	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12140	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12141	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12142	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12143	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12144	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12145	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12146        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12147
12148	/*
12149	 * Set up output mixers (0x0c - 0x0e)
12150	 */
12151	/* set vol=0 to output mixers */
12152	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12153	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12154	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12155
12156	/* set up input amps for analog loopback */
12157	/* Amp Indices: DAC = 0, mixer = 1 */
12158	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12159	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12160	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12161	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12162	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12163	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12164
12165	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12166	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12167	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12168
12169	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12170	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12171
12172	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12173	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12174
12175	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12176	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12177        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12178	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12179	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12180
12181	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12182	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12183        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12184	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12185	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12186	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12187
12188
12189	/* FIXME: use matrix-type input source selection */
12190	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12191	/* Input mixer1: only unmute Mic */
12192	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12193	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12194	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12195	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12196	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12197	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12198	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12199	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12200	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12201	/* Input mixer2 */
12202	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12203	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12204	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12205	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12206	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12207	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12208	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12209	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12210	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12211	/* Input mixer3 */
12212	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12213	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12214	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12215	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12216	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12217	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12218	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12219	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12220	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12221
12222	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12223
12224	{ }
12225};
12226
12227static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12228	/*
12229	 * Unmute ADC0-2 and set the default input to mic-in
12230	 */
12231	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12232	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12233	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12234	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12235	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12236	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12237
12238	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12239	 * mixer widget
12240	 * Note: PASD motherboards uses the Line In 2 as the input for front
12241	 * panel mic (mic 2)
12242	 */
12243	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12244	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12245	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12246	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12247	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12248	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12249	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12250	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12251	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12252	/*
12253	 * Set up output mixers (0x0c - 0x0e)
12254	 */
12255	/* set vol=0 to output mixers */
12256	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12257	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12258	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12259
12260	/* set up input amps for analog loopback */
12261	/* Amp Indices: DAC = 0, mixer = 1 */
12262	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12263	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12264	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12265	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12266	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12267	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12268
12269
12270	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
12271	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
12272	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
12273	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
12274	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
12275	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
12276	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
12277
12278	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12279	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12280
12281	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12282	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12283
12284	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12285	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12286	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12287	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12288	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12289	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12290
12291	/* FIXME: use matrix-type input source selection */
12292	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12293	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12294	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12295	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12296	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12297	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12298	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12299        /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12300	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12301	/* Input mixer2 */
12302	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12303	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12304	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12305	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12306	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12307        /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12308	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12309	/* Input mixer3 */
12310	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12311	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12312	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12313	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12314	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12315        /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12316	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12317
12318	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12319
12320	{ }
12321};
12322
12323static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12324
12325	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
12326	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12327	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12328
12329	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
12330	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
12331	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12332	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12333
12334	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
12335	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12336	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12337	{}
12338};
12339
12340/*
12341 * Pin config fixes
12342 */
12343enum {
12344	PINFIX_FSC_H270,
12345};
12346
12347static const struct alc_fixup alc262_fixups[] = {
12348	[PINFIX_FSC_H270] = {
12349		.pins = (const struct alc_pincfg[]) {
12350			{ 0x14, 0x99130110 }, /* speaker */
12351			{ 0x15, 0x0221142f }, /* front HP */
12352			{ 0x1b, 0x0121141f }, /* rear HP */
12353			{ }
12354		}
12355	},
12356	[PINFIX_PB_M5210] = {
12357		.verbs = (const struct hda_verb[]) {
12358			{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
12359			{}
12360		}
12361	},
12362};
12363
12364static struct snd_pci_quirk alc262_fixup_tbl[] = {
12365	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12366	{}
12367};
12368
12369
12370#ifdef CONFIG_SND_HDA_POWER_SAVE
12371#define alc262_loopbacks	alc880_loopbacks
12372#endif
12373
12374/* pcm configuration: identical with ALC880 */
12375#define alc262_pcm_analog_playback	alc880_pcm_analog_playback
12376#define alc262_pcm_analog_capture	alc880_pcm_analog_capture
12377#define alc262_pcm_digital_playback	alc880_pcm_digital_playback
12378#define alc262_pcm_digital_capture	alc880_pcm_digital_capture
12379
12380/*
12381 * BIOS auto configuration
12382 */
12383static int alc262_parse_auto_config(struct hda_codec *codec)
12384{
12385	struct alc_spec *spec = codec->spec;
12386	int err;
12387	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12388
12389	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12390					   alc262_ignore);
12391	if (err < 0)
12392		return err;
12393	if (!spec->autocfg.line_outs) {
12394		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12395			spec->multiout.max_channels = 2;
12396			spec->no_analog = 1;
12397			goto dig_only;
12398		}
12399		return 0; /* can't find valid BIOS pin config */
12400	}
12401	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12402	if (err < 0)
12403		return err;
12404	err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12405	if (err < 0)
12406		return err;
12407
12408	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12409
12410 dig_only:
12411	alc_auto_parse_digital(codec);
12412
12413	if (spec->kctls.list)
12414		add_mixer(spec, spec->kctls.list);
12415
12416	add_verb(spec, alc262_volume_init_verbs);
12417	spec->num_mux_defs = 1;
12418	spec->input_mux = &spec->private_imux[0];
12419
12420	err = alc_auto_add_mic_boost(codec);
12421	if (err < 0)
12422		return err;
12423
12424	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12425
12426	return 1;
12427}
12428
12429#define alc262_auto_init_multi_out	alc882_auto_init_multi_out
12430#define alc262_auto_init_hp_out		alc882_auto_init_hp_out
12431#define alc262_auto_init_analog_input	alc882_auto_init_analog_input
12432#define alc262_auto_init_input_src	alc882_auto_init_input_src
12433
12434
12435/* init callback for auto-configuration model -- overriding the default init */
12436static void alc262_auto_init(struct hda_codec *codec)
12437{
12438	struct alc_spec *spec = codec->spec;
12439	alc262_auto_init_multi_out(codec);
12440	alc262_auto_init_hp_out(codec);
12441	alc262_auto_init_analog_input(codec);
12442	alc262_auto_init_input_src(codec);
12443	alc_auto_init_digital(codec);
12444	if (spec->unsol_event)
12445		alc_inithook(codec);
12446}
12447
12448/*
12449 * configuration and preset
12450 */
12451static const char *alc262_models[ALC262_MODEL_LAST] = {
12452	[ALC262_BASIC]		= "basic",
12453	[ALC262_HIPPO]		= "hippo",
12454	[ALC262_HIPPO_1]	= "hippo_1",
12455	[ALC262_FUJITSU]	= "fujitsu",
12456	[ALC262_HP_BPC]		= "hp-bpc",
12457	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12458	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
12459	[ALC262_HP_RP5700]	= "hp-rp5700",
12460	[ALC262_BENQ_ED8]	= "benq",
12461	[ALC262_BENQ_T31]	= "benq-t31",
12462	[ALC262_SONY_ASSAMD]	= "sony-assamd",
12463	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
12464	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
12465	[ALC262_ULTRA]		= "ultra",
12466	[ALC262_LENOVO_3000]	= "lenovo-3000",
12467	[ALC262_NEC]		= "nec",
12468	[ALC262_TYAN]		= "tyan",
12469	[ALC262_AUTO]		= "auto",
12470};
12471
12472static struct snd_pci_quirk alc262_cfg_tbl[] = {
12473	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12474	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12475	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12476			   ALC262_HP_BPC),
12477	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12478			   ALC262_HP_BPC),
12479	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12480			   ALC262_HP_BPC),
12481	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12482	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12483	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12484	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12485	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12486	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12487	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12488	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12489	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12490	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12491	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12492	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12493		      ALC262_HP_TC_T5735),
12494	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12495	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12496	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12497	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12498	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12499	SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12500	SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12501	SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12502#if 0 /* disable the quirk since model=auto works better in recent versions */
12503	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12504			   ALC262_SONY_ASSAMD),
12505#endif
12506	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12507		      ALC262_TOSHIBA_RX1),
12508	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12509	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12510	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12511	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12512	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12513			   ALC262_ULTRA),
12514	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12515	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12516	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12517	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12518	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12519	{}
12520};
12521
12522static struct alc_config_preset alc262_presets[] = {
12523	[ALC262_BASIC] = {
12524		.mixers = { alc262_base_mixer },
12525		.init_verbs = { alc262_init_verbs },
12526		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12527		.dac_nids = alc262_dac_nids,
12528		.hp_nid = 0x03,
12529		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12530		.channel_mode = alc262_modes,
12531		.input_mux = &alc262_capture_source,
12532	},
12533	[ALC262_HIPPO] = {
12534		.mixers = { alc262_hippo_mixer },
12535		.init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12536		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12537		.dac_nids = alc262_dac_nids,
12538		.hp_nid = 0x03,
12539		.dig_out_nid = ALC262_DIGOUT_NID,
12540		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12541		.channel_mode = alc262_modes,
12542		.input_mux = &alc262_capture_source,
12543		.unsol_event = alc262_hippo_unsol_event,
12544		.setup = alc262_hippo_setup,
12545		.init_hook = alc262_hippo_automute,
12546	},
12547	[ALC262_HIPPO_1] = {
12548		.mixers = { alc262_hippo1_mixer },
12549		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12550		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12551		.dac_nids = alc262_dac_nids,
12552		.hp_nid = 0x02,
12553		.dig_out_nid = ALC262_DIGOUT_NID,
12554		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12555		.channel_mode = alc262_modes,
12556		.input_mux = &alc262_capture_source,
12557		.unsol_event = alc262_hippo_unsol_event,
12558		.setup = alc262_hippo1_setup,
12559		.init_hook = alc262_hippo_automute,
12560	},
12561	[ALC262_FUJITSU] = {
12562		.mixers = { alc262_fujitsu_mixer },
12563		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12564				alc262_fujitsu_unsol_verbs },
12565		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12566		.dac_nids = alc262_dac_nids,
12567		.hp_nid = 0x03,
12568		.dig_out_nid = ALC262_DIGOUT_NID,
12569		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12570		.channel_mode = alc262_modes,
12571		.input_mux = &alc262_fujitsu_capture_source,
12572		.unsol_event = alc262_fujitsu_unsol_event,
12573		.init_hook = alc262_fujitsu_init_hook,
12574	},
12575	[ALC262_HP_BPC] = {
12576		.mixers = { alc262_HP_BPC_mixer },
12577		.init_verbs = { alc262_HP_BPC_init_verbs },
12578		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12579		.dac_nids = alc262_dac_nids,
12580		.hp_nid = 0x03,
12581		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12582		.channel_mode = alc262_modes,
12583		.input_mux = &alc262_HP_capture_source,
12584		.unsol_event = alc262_hp_bpc_unsol_event,
12585		.init_hook = alc262_hp_bpc_automute,
12586	},
12587	[ALC262_HP_BPC_D7000_WF] = {
12588		.mixers = { alc262_HP_BPC_WildWest_mixer },
12589		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12590		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12591		.dac_nids = alc262_dac_nids,
12592		.hp_nid = 0x03,
12593		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12594		.channel_mode = alc262_modes,
12595		.input_mux = &alc262_HP_D7000_capture_source,
12596		.unsol_event = alc262_hp_wildwest_unsol_event,
12597		.init_hook = alc262_hp_wildwest_automute,
12598	},
12599	[ALC262_HP_BPC_D7000_WL] = {
12600		.mixers = { alc262_HP_BPC_WildWest_mixer,
12601			    alc262_HP_BPC_WildWest_option_mixer },
12602		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12603		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12604		.dac_nids = alc262_dac_nids,
12605		.hp_nid = 0x03,
12606		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12607		.channel_mode = alc262_modes,
12608		.input_mux = &alc262_HP_D7000_capture_source,
12609		.unsol_event = alc262_hp_wildwest_unsol_event,
12610		.init_hook = alc262_hp_wildwest_automute,
12611	},
12612	[ALC262_HP_TC_T5735] = {
12613		.mixers = { alc262_hp_t5735_mixer },
12614		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12615		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12616		.dac_nids = alc262_dac_nids,
12617		.hp_nid = 0x03,
12618		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12619		.channel_mode = alc262_modes,
12620		.input_mux = &alc262_capture_source,
12621		.unsol_event = alc_sku_unsol_event,
12622		.setup = alc262_hp_t5735_setup,
12623		.init_hook = alc_inithook,
12624	},
12625	[ALC262_HP_RP5700] = {
12626		.mixers = { alc262_hp_rp5700_mixer },
12627		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12628		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12629		.dac_nids = alc262_dac_nids,
12630		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12631		.channel_mode = alc262_modes,
12632		.input_mux = &alc262_hp_rp5700_capture_source,
12633        },
12634	[ALC262_BENQ_ED8] = {
12635		.mixers = { alc262_base_mixer },
12636		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12637		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12638		.dac_nids = alc262_dac_nids,
12639		.hp_nid = 0x03,
12640		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12641		.channel_mode = alc262_modes,
12642		.input_mux = &alc262_capture_source,
12643	},
12644	[ALC262_SONY_ASSAMD] = {
12645		.mixers = { alc262_sony_mixer },
12646		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12647		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12648		.dac_nids = alc262_dac_nids,
12649		.hp_nid = 0x02,
12650		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12651		.channel_mode = alc262_modes,
12652		.input_mux = &alc262_capture_source,
12653		.unsol_event = alc262_hippo_unsol_event,
12654		.setup = alc262_hippo_setup,
12655		.init_hook = alc262_hippo_automute,
12656	},
12657	[ALC262_BENQ_T31] = {
12658		.mixers = { alc262_benq_t31_mixer },
12659		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12660				alc_hp15_unsol_verbs },
12661		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12662		.dac_nids = alc262_dac_nids,
12663		.hp_nid = 0x03,
12664		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12665		.channel_mode = alc262_modes,
12666		.input_mux = &alc262_capture_source,
12667		.unsol_event = alc262_hippo_unsol_event,
12668		.setup = alc262_hippo_setup,
12669		.init_hook = alc262_hippo_automute,
12670	},
12671	[ALC262_ULTRA] = {
12672		.mixers = { alc262_ultra_mixer },
12673		.cap_mixer = alc262_ultra_capture_mixer,
12674		.init_verbs = { alc262_ultra_verbs },
12675		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12676		.dac_nids = alc262_dac_nids,
12677		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12678		.channel_mode = alc262_modes,
12679		.input_mux = &alc262_ultra_capture_source,
12680		.adc_nids = alc262_adc_nids, /* ADC0 */
12681		.capsrc_nids = alc262_capsrc_nids,
12682		.num_adc_nids = 1, /* single ADC */
12683		.unsol_event = alc262_ultra_unsol_event,
12684		.init_hook = alc262_ultra_automute,
12685	},
12686	[ALC262_LENOVO_3000] = {
12687		.mixers = { alc262_lenovo_3000_mixer },
12688		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12689				alc262_lenovo_3000_unsol_verbs,
12690				alc262_lenovo_3000_init_verbs },
12691		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12692		.dac_nids = alc262_dac_nids,
12693		.hp_nid = 0x03,
12694		.dig_out_nid = ALC262_DIGOUT_NID,
12695		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12696		.channel_mode = alc262_modes,
12697		.input_mux = &alc262_fujitsu_capture_source,
12698		.unsol_event = alc262_lenovo_3000_unsol_event,
12699	},
12700	[ALC262_NEC] = {
12701		.mixers = { alc262_nec_mixer },
12702		.init_verbs = { alc262_nec_verbs },
12703		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12704		.dac_nids = alc262_dac_nids,
12705		.hp_nid = 0x03,
12706		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12707		.channel_mode = alc262_modes,
12708		.input_mux = &alc262_capture_source,
12709	},
12710	[ALC262_TOSHIBA_S06] = {
12711		.mixers = { alc262_toshiba_s06_mixer },
12712		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12713							alc262_eapd_verbs },
12714		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12715		.capsrc_nids = alc262_dmic_capsrc_nids,
12716		.dac_nids = alc262_dac_nids,
12717		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12718		.num_adc_nids = 1, /* single ADC */
12719		.dig_out_nid = ALC262_DIGOUT_NID,
12720		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12721		.channel_mode = alc262_modes,
12722		.unsol_event = alc_sku_unsol_event,
12723		.setup = alc262_toshiba_s06_setup,
12724		.init_hook = alc_inithook,
12725	},
12726	[ALC262_TOSHIBA_RX1] = {
12727		.mixers = { alc262_toshiba_rx1_mixer },
12728		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12729		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12730		.dac_nids = alc262_dac_nids,
12731		.hp_nid = 0x03,
12732		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12733		.channel_mode = alc262_modes,
12734		.input_mux = &alc262_capture_source,
12735		.unsol_event = alc262_hippo_unsol_event,
12736		.setup = alc262_hippo_setup,
12737		.init_hook = alc262_hippo_automute,
12738	},
12739	[ALC262_TYAN] = {
12740		.mixers = { alc262_tyan_mixer },
12741		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12742		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12743		.dac_nids = alc262_dac_nids,
12744		.hp_nid = 0x02,
12745		.dig_out_nid = ALC262_DIGOUT_NID,
12746		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12747		.channel_mode = alc262_modes,
12748		.input_mux = &alc262_capture_source,
12749		.unsol_event = alc_automute_amp_unsol_event,
12750		.setup = alc262_tyan_setup,
12751		.init_hook = alc_automute_amp,
12752	},
12753};
12754
12755static int patch_alc262(struct hda_codec *codec)
12756{
12757	struct alc_spec *spec;
12758	int board_config;
12759	int err;
12760
12761	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12762	if (spec == NULL)
12763		return -ENOMEM;
12764
12765	codec->spec = spec;
12766#if 0
12767	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12768	 * under-run
12769	 */
12770	{
12771	int tmp;
12772	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12773	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12774	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12775	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12776	}
12777#endif
12778	alc_auto_parse_customize_define(codec);
12779
12780	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12781
12782	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12783						  alc262_models,
12784						  alc262_cfg_tbl);
12785
12786	if (board_config < 0) {
12787		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12788		       codec->chip_name);
12789		board_config = ALC262_AUTO;
12790	}
12791
12792	if (board_config == ALC262_AUTO)
12793		alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1);
12794
12795	if (board_config == ALC262_AUTO) {
12796		/* automatic parse from the BIOS config */
12797		err = alc262_parse_auto_config(codec);
12798		if (err < 0) {
12799			alc_free(codec);
12800			return err;
12801		} else if (!err) {
12802			printk(KERN_INFO
12803			       "hda_codec: Cannot set up configuration "
12804			       "from BIOS.  Using base mode...\n");
12805			board_config = ALC262_BASIC;
12806		}
12807	}
12808
12809	if (!spec->no_analog && has_cdefine_beep(codec)) {
12810		err = snd_hda_attach_beep_device(codec, 0x1);
12811		if (err < 0) {
12812			alc_free(codec);
12813			return err;
12814		}
12815	}
12816
12817	if (board_config != ALC262_AUTO)
12818		setup_preset(codec, &alc262_presets[board_config]);
12819
12820	spec->stream_analog_playback = &alc262_pcm_analog_playback;
12821	spec->stream_analog_capture = &alc262_pcm_analog_capture;
12822
12823	spec->stream_digital_playback = &alc262_pcm_digital_playback;
12824	spec->stream_digital_capture = &alc262_pcm_digital_capture;
12825
12826	if (!spec->adc_nids && spec->input_mux) {
12827		int i;
12828		/* check whether the digital-mic has to be supported */
12829		for (i = 0; i < spec->input_mux->num_items; i++) {
12830			if (spec->input_mux->items[i].index >= 9)
12831				break;
12832		}
12833		if (i < spec->input_mux->num_items) {
12834			/* use only ADC0 */
12835			spec->adc_nids = alc262_dmic_adc_nids;
12836			spec->num_adc_nids = 1;
12837			spec->capsrc_nids = alc262_dmic_capsrc_nids;
12838		} else {
12839			/* all analog inputs */
12840			/* check whether NID 0x07 is valid */
12841			unsigned int wcap = get_wcaps(codec, 0x07);
12842
12843			/* get type */
12844			wcap = get_wcaps_type(wcap);
12845			if (wcap != AC_WID_AUD_IN) {
12846				spec->adc_nids = alc262_adc_nids_alt;
12847				spec->num_adc_nids =
12848					ARRAY_SIZE(alc262_adc_nids_alt);
12849				spec->capsrc_nids = alc262_capsrc_nids_alt;
12850			} else {
12851				spec->adc_nids = alc262_adc_nids;
12852				spec->num_adc_nids =
12853					ARRAY_SIZE(alc262_adc_nids);
12854				spec->capsrc_nids = alc262_capsrc_nids;
12855			}
12856		}
12857	}
12858	if (!spec->cap_mixer && !spec->no_analog)
12859		set_capture_mixer(codec);
12860	if (!spec->no_analog && has_cdefine_beep(codec))
12861		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12862
12863	if (board_config == ALC262_AUTO)
12864		alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0);
12865
12866	spec->vmaster_nid = 0x0c;
12867
12868	codec->patch_ops = alc_patch_ops;
12869	if (board_config == ALC262_AUTO)
12870		spec->init_hook = alc262_auto_init;
12871#ifdef CONFIG_SND_HDA_POWER_SAVE
12872	if (!spec->loopback.amplist)
12873		spec->loopback.amplist = alc262_loopbacks;
12874#endif
12875
12876	return 0;
12877}
12878
12879/*
12880 *  ALC268 channel source setting (2 channel)
12881 */
12882#define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
12883#define alc268_modes		alc260_modes
12884
12885static hda_nid_t alc268_dac_nids[2] = {
12886	/* front, hp */
12887	0x02, 0x03
12888};
12889
12890static hda_nid_t alc268_adc_nids[2] = {
12891	/* ADC0-1 */
12892	0x08, 0x07
12893};
12894
12895static hda_nid_t alc268_adc_nids_alt[1] = {
12896	/* ADC0 */
12897	0x08
12898};
12899
12900static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12901
12902static struct snd_kcontrol_new alc268_base_mixer[] = {
12903	/* output mixer control */
12904	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12905	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12906	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12907	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12908	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12909	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12910	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12911	{ }
12912};
12913
12914static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12915	/* output mixer control */
12916	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12917	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12918	ALC262_HIPPO_MASTER_SWITCH,
12919	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12920	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12921	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12922	{ }
12923};
12924
12925/* bind Beep switches of both NID 0x0f and 0x10 */
12926static struct hda_bind_ctls alc268_bind_beep_sw = {
12927	.ops = &snd_hda_bind_sw,
12928	.values = {
12929		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12930		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12931		0
12932	},
12933};
12934
12935static struct snd_kcontrol_new alc268_beep_mixer[] = {
12936	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12937	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12938	{ }
12939};
12940
12941static struct hda_verb alc268_eapd_verbs[] = {
12942	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12943	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12944	{ }
12945};
12946
12947/* Toshiba specific */
12948static struct hda_verb alc268_toshiba_verbs[] = {
12949	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12950	{ } /* end */
12951};
12952
12953/* Acer specific */
12954/* bind volumes of both NID 0x02 and 0x03 */
12955static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12956	.ops = &snd_hda_bind_vol,
12957	.values = {
12958		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12959		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12960		0
12961	},
12962};
12963
12964/* mute/unmute internal speaker according to the hp jack and mute state */
12965static void alc268_acer_automute(struct hda_codec *codec, int force)
12966{
12967	struct alc_spec *spec = codec->spec;
12968	unsigned int mute;
12969
12970	if (force || !spec->sense_updated) {
12971		spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12972		spec->sense_updated = 1;
12973	}
12974	if (spec->jack_present)
12975		mute = HDA_AMP_MUTE; /* mute internal speaker */
12976	else /* unmute internal speaker if necessary */
12977		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12978	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12979				 HDA_AMP_MUTE, mute);
12980}
12981
12982
12983/* bind hp and internal speaker mute (with plug check) */
12984static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12985				     struct snd_ctl_elem_value *ucontrol)
12986{
12987	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12988	long *valp = ucontrol->value.integer.value;
12989	int change;
12990
12991	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12992	if (change)
12993		alc268_acer_automute(codec, 0);
12994	return change;
12995}
12996
12997static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12998	/* output mixer control */
12999	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13000	{
13001		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13002		.name = "Master Playback Switch",
13003		.subdevice = HDA_SUBDEV_AMP_FLAG,
13004		.info = snd_hda_mixer_amp_switch_info,
13005		.get = snd_hda_mixer_amp_switch_get,
13006		.put = alc268_acer_master_sw_put,
13007		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13008	},
13009	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13010	{ }
13011};
13012
13013static struct snd_kcontrol_new alc268_acer_mixer[] = {
13014	/* output mixer control */
13015	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13016	{
13017		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13018		.name = "Master Playback Switch",
13019		.subdevice = HDA_SUBDEV_AMP_FLAG,
13020		.info = snd_hda_mixer_amp_switch_info,
13021		.get = snd_hda_mixer_amp_switch_get,
13022		.put = alc268_acer_master_sw_put,
13023		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13024	},
13025	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13026	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13027	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13028	{ }
13029};
13030
13031static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13032	/* output mixer control */
13033	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13034	{
13035		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13036		.name = "Master Playback Switch",
13037		.subdevice = HDA_SUBDEV_AMP_FLAG,
13038		.info = snd_hda_mixer_amp_switch_info,
13039		.get = snd_hda_mixer_amp_switch_get,
13040		.put = alc268_acer_master_sw_put,
13041		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13042	},
13043	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13044	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13045	{ }
13046};
13047
13048static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13049	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13050	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13051	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13052	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13053	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13054	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13055	{ }
13056};
13057
13058static struct hda_verb alc268_acer_verbs[] = {
13059	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13060	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13061	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13062	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13063	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13064	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13065	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13066	{ }
13067};
13068
13069/* unsolicited event for HP jack sensing */
13070#define alc268_toshiba_unsol_event	alc262_hippo_unsol_event
13071#define alc268_toshiba_setup		alc262_hippo_setup
13072#define alc268_toshiba_automute		alc262_hippo_automute
13073
13074static void alc268_acer_unsol_event(struct hda_codec *codec,
13075				       unsigned int res)
13076{
13077	if ((res >> 26) != ALC880_HP_EVENT)
13078		return;
13079	alc268_acer_automute(codec, 1);
13080}
13081
13082static void alc268_acer_init_hook(struct hda_codec *codec)
13083{
13084	alc268_acer_automute(codec, 1);
13085}
13086
13087/* toggle speaker-output according to the hp-jack state */
13088static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13089{
13090	unsigned int present;
13091	unsigned char bits;
13092
13093	present = snd_hda_jack_detect(codec, 0x15);
13094	bits = present ? HDA_AMP_MUTE : 0;
13095	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13096				 HDA_AMP_MUTE, bits);
13097	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13098				 HDA_AMP_MUTE, bits);
13099}
13100
13101static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13102				    unsigned int res)
13103{
13104	switch (res >> 26) {
13105	case ALC880_HP_EVENT:
13106		alc268_aspire_one_speaker_automute(codec);
13107		break;
13108	case ALC880_MIC_EVENT:
13109		alc_mic_automute(codec);
13110		break;
13111	}
13112}
13113
13114static void alc268_acer_lc_setup(struct hda_codec *codec)
13115{
13116	struct alc_spec *spec = codec->spec;
13117	spec->ext_mic.pin = 0x18;
13118	spec->ext_mic.mux_idx = 0;
13119	spec->int_mic.pin = 0x12;
13120	spec->int_mic.mux_idx = 6;
13121	spec->auto_mic = 1;
13122}
13123
13124static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13125{
13126	alc268_aspire_one_speaker_automute(codec);
13127	alc_mic_automute(codec);
13128}
13129
13130static struct snd_kcontrol_new alc268_dell_mixer[] = {
13131	/* output mixer control */
13132	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13133	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13134	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13135	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13136	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13137	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13138	{ }
13139};
13140
13141static struct hda_verb alc268_dell_verbs[] = {
13142	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13143	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13144	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13145	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13146	{ }
13147};
13148
13149/* mute/unmute internal speaker according to the hp jack and mute state */
13150static void alc268_dell_setup(struct hda_codec *codec)
13151{
13152	struct alc_spec *spec = codec->spec;
13153
13154	spec->autocfg.hp_pins[0] = 0x15;
13155	spec->autocfg.speaker_pins[0] = 0x14;
13156	spec->ext_mic.pin = 0x18;
13157	spec->ext_mic.mux_idx = 0;
13158	spec->int_mic.pin = 0x19;
13159	spec->int_mic.mux_idx = 1;
13160	spec->auto_mic = 1;
13161}
13162
13163static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13164	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13165	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13166	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13167	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13168	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13169	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13170	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13171	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13172	{ }
13173};
13174
13175static struct hda_verb alc267_quanta_il1_verbs[] = {
13176	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13177	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13178	{ }
13179};
13180
13181static void alc267_quanta_il1_setup(struct hda_codec *codec)
13182{
13183	struct alc_spec *spec = codec->spec;
13184	spec->autocfg.hp_pins[0] = 0x15;
13185	spec->autocfg.speaker_pins[0] = 0x14;
13186	spec->ext_mic.pin = 0x18;
13187	spec->ext_mic.mux_idx = 0;
13188	spec->int_mic.pin = 0x19;
13189	spec->int_mic.mux_idx = 1;
13190	spec->auto_mic = 1;
13191}
13192
13193/*
13194 * generic initialization of ADC, input mixers and output mixers
13195 */
13196static struct hda_verb alc268_base_init_verbs[] = {
13197	/* Unmute DAC0-1 and set vol = 0 */
13198	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13199	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13200
13201	/*
13202	 * Set up output mixers (0x0c - 0x0e)
13203	 */
13204	/* set vol=0 to output mixers */
13205	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13206        {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13207
13208	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13209	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13210
13211	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13212	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13213	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13214	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13215	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13216	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13217	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13218	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13219
13220	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13221	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13222	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13223	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13224	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13225
13226	/* set PCBEEP vol = 0, mute connections */
13227	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13228	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13229	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13230
13231	/* Unmute Selector 23h,24h and set the default input to mic-in */
13232
13233	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13234	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13235	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13236	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13237
13238	{ }
13239};
13240
13241/*
13242 * generic initialization of ADC, input mixers and output mixers
13243 */
13244static struct hda_verb alc268_volume_init_verbs[] = {
13245	/* set output DAC */
13246	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13247	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13248
13249	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13250	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13251	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13252	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13253	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13254
13255	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13256	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13257	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13258
13259	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13260	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13261
13262	/* set PCBEEP vol = 0, mute connections */
13263	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13264	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13265	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13266
13267	{ }
13268};
13269
13270static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13271	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13272	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13273	{ } /* end */
13274};
13275
13276static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13277	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13278	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13279	_DEFINE_CAPSRC(1),
13280	{ } /* end */
13281};
13282
13283static struct snd_kcontrol_new alc268_capture_mixer[] = {
13284	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13285	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13286	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13287	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13288	_DEFINE_CAPSRC(2),
13289	{ } /* end */
13290};
13291
13292static struct hda_input_mux alc268_capture_source = {
13293	.num_items = 4,
13294	.items = {
13295		{ "Mic", 0x0 },
13296		{ "Front Mic", 0x1 },
13297		{ "Line", 0x2 },
13298		{ "CD", 0x3 },
13299	},
13300};
13301
13302static struct hda_input_mux alc268_acer_capture_source = {
13303	.num_items = 3,
13304	.items = {
13305		{ "Mic", 0x0 },
13306		{ "Internal Mic", 0x1 },
13307		{ "Line", 0x2 },
13308	},
13309};
13310
13311static struct hda_input_mux alc268_acer_dmic_capture_source = {
13312	.num_items = 3,
13313	.items = {
13314		{ "Mic", 0x0 },
13315		{ "Internal Mic", 0x6 },
13316		{ "Line", 0x2 },
13317	},
13318};
13319
13320#ifdef CONFIG_SND_DEBUG
13321static struct snd_kcontrol_new alc268_test_mixer[] = {
13322	/* Volume widgets */
13323	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13324	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13325	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13326	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13327	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13328	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13329	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13330	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13331	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13332	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13333	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13334	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13335	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13336	/* The below appears problematic on some hardwares */
13337	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13338	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13339	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13340	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13341	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13342
13343	/* Modes for retasking pin widgets */
13344	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13345	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13346	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13347	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13348
13349	/* Controls for GPIO pins, assuming they are configured as outputs */
13350	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13351	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13352	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13353	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13354
13355	/* Switches to allow the digital SPDIF output pin to be enabled.
13356	 * The ALC268 does not have an SPDIF input.
13357	 */
13358	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13359
13360	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
13361	 * this output to turn on an external amplifier.
13362	 */
13363	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13364	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13365
13366	{ } /* end */
13367};
13368#endif
13369
13370/* create input playback/capture controls for the given pin */
13371static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13372				    const char *ctlname, int idx)
13373{
13374	hda_nid_t dac;
13375	int err;
13376
13377	switch (nid) {
13378	case 0x14:
13379	case 0x16:
13380		dac = 0x02;
13381		break;
13382	case 0x15:
13383	case 0x1a: /* ALC259/269 only */
13384	case 0x1b: /* ALC259/269 only */
13385	case 0x21: /* ALC269vb has this pin, too */
13386		dac = 0x03;
13387		break;
13388	default:
13389		snd_printd(KERN_WARNING "hda_codec: "
13390			   "ignoring pin 0x%x as unknown\n", nid);
13391		return 0;
13392	}
13393	if (spec->multiout.dac_nids[0] != dac &&
13394	    spec->multiout.dac_nids[1] != dac) {
13395		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13396				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13397						      HDA_OUTPUT));
13398		if (err < 0)
13399			return err;
13400		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13401	}
13402
13403	if (nid != 0x16)
13404		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13405			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13406	else /* mono */
13407		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13408			  HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13409	if (err < 0)
13410		return err;
13411	return 0;
13412}
13413
13414/* add playback controls from the parsed DAC table */
13415static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13416					     const struct auto_pin_cfg *cfg)
13417{
13418	hda_nid_t nid;
13419	int err;
13420
13421	spec->multiout.dac_nids = spec->private_dac_nids;
13422
13423	nid = cfg->line_out_pins[0];
13424	if (nid) {
13425		const char *name;
13426		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13427			name = "Speaker";
13428		else
13429			name = "Front";
13430		err = alc268_new_analog_output(spec, nid, name, 0);
13431		if (err < 0)
13432			return err;
13433	}
13434
13435	nid = cfg->speaker_pins[0];
13436	if (nid == 0x1d) {
13437		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13438				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13439		if (err < 0)
13440			return err;
13441	} else if (nid) {
13442		err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13443		if (err < 0)
13444			return err;
13445	}
13446	nid = cfg->hp_pins[0];
13447	if (nid) {
13448		err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13449		if (err < 0)
13450			return err;
13451	}
13452
13453	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13454	if (nid == 0x16) {
13455		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13456				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13457		if (err < 0)
13458			return err;
13459	}
13460	return 0;
13461}
13462
13463/* create playback/capture controls for input pins */
13464static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13465						const struct auto_pin_cfg *cfg)
13466{
13467	return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13468}
13469
13470static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13471					      hda_nid_t nid, int pin_type)
13472{
13473	int idx;
13474
13475	alc_set_pin_output(codec, nid, pin_type);
13476	if (nid == 0x14 || nid == 0x16)
13477		idx = 0;
13478	else
13479		idx = 1;
13480	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13481}
13482
13483static void alc268_auto_init_multi_out(struct hda_codec *codec)
13484{
13485	struct alc_spec *spec = codec->spec;
13486	int i;
13487
13488	for (i = 0; i < spec->autocfg.line_outs; i++) {
13489		hda_nid_t nid = spec->autocfg.line_out_pins[i];
13490		int pin_type = get_pin_type(spec->autocfg.line_out_type);
13491		alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13492	}
13493}
13494
13495static void alc268_auto_init_hp_out(struct hda_codec *codec)
13496{
13497	struct alc_spec *spec = codec->spec;
13498	hda_nid_t pin;
13499	int i;
13500
13501	for (i = 0; i < spec->autocfg.hp_outs; i++) {
13502		pin = spec->autocfg.hp_pins[i];
13503		alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13504	}
13505	for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13506		pin = spec->autocfg.speaker_pins[i];
13507		alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13508	}
13509	if (spec->autocfg.mono_out_pin)
13510		snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13511				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13512}
13513
13514static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13515{
13516	struct alc_spec *spec = codec->spec;
13517	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13518	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13519	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13520	unsigned int	dac_vol1, dac_vol2;
13521
13522	if (line_nid == 0x1d || speaker_nid == 0x1d) {
13523		snd_hda_codec_write(codec, speaker_nid, 0,
13524				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13525		/* mute mixer inputs from 0x1d */
13526		snd_hda_codec_write(codec, 0x0f, 0,
13527				    AC_VERB_SET_AMP_GAIN_MUTE,
13528				    AMP_IN_UNMUTE(1));
13529		snd_hda_codec_write(codec, 0x10, 0,
13530				    AC_VERB_SET_AMP_GAIN_MUTE,
13531				    AMP_IN_UNMUTE(1));
13532	} else {
13533		/* unmute mixer inputs from 0x1d */
13534		snd_hda_codec_write(codec, 0x0f, 0,
13535				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13536		snd_hda_codec_write(codec, 0x10, 0,
13537				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13538	}
13539
13540	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
13541	if (line_nid == 0x14)
13542		dac_vol2 = AMP_OUT_ZERO;
13543	else if (line_nid == 0x15)
13544		dac_vol1 = AMP_OUT_ZERO;
13545	if (hp_nid == 0x14)
13546		dac_vol2 = AMP_OUT_ZERO;
13547	else if (hp_nid == 0x15)
13548		dac_vol1 = AMP_OUT_ZERO;
13549	if (line_nid != 0x16 || hp_nid != 0x16 ||
13550	    spec->autocfg.line_out_pins[1] != 0x16 ||
13551	    spec->autocfg.line_out_pins[2] != 0x16)
13552		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13553
13554	snd_hda_codec_write(codec, 0x02, 0,
13555			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13556	snd_hda_codec_write(codec, 0x03, 0,
13557			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13558}
13559
13560/* pcm configuration: identical with ALC880 */
13561#define alc268_pcm_analog_playback	alc880_pcm_analog_playback
13562#define alc268_pcm_analog_capture	alc880_pcm_analog_capture
13563#define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
13564#define alc268_pcm_digital_playback	alc880_pcm_digital_playback
13565
13566/*
13567 * BIOS auto configuration
13568 */
13569static int alc268_parse_auto_config(struct hda_codec *codec)
13570{
13571	struct alc_spec *spec = codec->spec;
13572	int err;
13573	static hda_nid_t alc268_ignore[] = { 0 };
13574
13575	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13576					   alc268_ignore);
13577	if (err < 0)
13578		return err;
13579	if (!spec->autocfg.line_outs) {
13580		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13581			spec->multiout.max_channels = 2;
13582			spec->no_analog = 1;
13583			goto dig_only;
13584		}
13585		return 0; /* can't find valid BIOS pin config */
13586	}
13587	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13588	if (err < 0)
13589		return err;
13590	err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13591	if (err < 0)
13592		return err;
13593
13594	spec->multiout.max_channels = 2;
13595
13596 dig_only:
13597	/* digital only support output */
13598	alc_auto_parse_digital(codec);
13599	if (spec->kctls.list)
13600		add_mixer(spec, spec->kctls.list);
13601
13602	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13603		add_mixer(spec, alc268_beep_mixer);
13604
13605	add_verb(spec, alc268_volume_init_verbs);
13606	spec->num_mux_defs = 2;
13607	spec->input_mux = &spec->private_imux[0];
13608
13609	err = alc_auto_add_mic_boost(codec);
13610	if (err < 0)
13611		return err;
13612
13613	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13614
13615	return 1;
13616}
13617
13618#define alc268_auto_init_analog_input	alc882_auto_init_analog_input
13619
13620/* init callback for auto-configuration model -- overriding the default init */
13621static void alc268_auto_init(struct hda_codec *codec)
13622{
13623	struct alc_spec *spec = codec->spec;
13624	alc268_auto_init_multi_out(codec);
13625	alc268_auto_init_hp_out(codec);
13626	alc268_auto_init_mono_speaker_out(codec);
13627	alc268_auto_init_analog_input(codec);
13628	alc_auto_init_digital(codec);
13629	if (spec->unsol_event)
13630		alc_inithook(codec);
13631}
13632
13633/*
13634 * configuration and preset
13635 */
13636static const char *alc268_models[ALC268_MODEL_LAST] = {
13637	[ALC267_QUANTA_IL1]	= "quanta-il1",
13638	[ALC268_3ST]		= "3stack",
13639	[ALC268_TOSHIBA]	= "toshiba",
13640	[ALC268_ACER]		= "acer",
13641	[ALC268_ACER_DMIC]	= "acer-dmic",
13642	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
13643	[ALC268_DELL]		= "dell",
13644	[ALC268_ZEPTO]		= "zepto",
13645#ifdef CONFIG_SND_DEBUG
13646	[ALC268_TEST]		= "test",
13647#endif
13648	[ALC268_AUTO]		= "auto",
13649};
13650
13651static struct snd_pci_quirk alc268_cfg_tbl[] = {
13652	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13653	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13654	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13655	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13656	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13657	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13658						ALC268_ACER_ASPIRE_ONE),
13659	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13660	SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13661			"Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13662	/* almost compatible with toshiba but with optional digital outs;
13663	 * auto-probing seems working fine
13664	 */
13665	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13666			   ALC268_AUTO),
13667	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13668	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13669	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13670	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13671	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13672	{}
13673};
13674
13675/* Toshiba laptops have no unique PCI SSID but only codec SSID */
13676static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13677	SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13678	SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13679	SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13680			   ALC268_TOSHIBA),
13681	{}
13682};
13683
13684static struct alc_config_preset alc268_presets[] = {
13685	[ALC267_QUANTA_IL1] = {
13686		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13687			    alc268_capture_nosrc_mixer },
13688		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13689				alc267_quanta_il1_verbs },
13690		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13691		.dac_nids = alc268_dac_nids,
13692		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13693		.adc_nids = alc268_adc_nids_alt,
13694		.hp_nid = 0x03,
13695		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13696		.channel_mode = alc268_modes,
13697		.unsol_event = alc_sku_unsol_event,
13698		.setup = alc267_quanta_il1_setup,
13699		.init_hook = alc_inithook,
13700	},
13701	[ALC268_3ST] = {
13702		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13703			    alc268_beep_mixer },
13704		.init_verbs = { alc268_base_init_verbs },
13705		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13706		.dac_nids = alc268_dac_nids,
13707                .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13708                .adc_nids = alc268_adc_nids_alt,
13709		.capsrc_nids = alc268_capsrc_nids,
13710		.hp_nid = 0x03,
13711		.dig_out_nid = ALC268_DIGOUT_NID,
13712		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13713		.channel_mode = alc268_modes,
13714		.input_mux = &alc268_capture_source,
13715	},
13716	[ALC268_TOSHIBA] = {
13717		.mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13718			    alc268_beep_mixer },
13719		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13720				alc268_toshiba_verbs },
13721		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13722		.dac_nids = alc268_dac_nids,
13723		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13724		.adc_nids = alc268_adc_nids_alt,
13725		.capsrc_nids = alc268_capsrc_nids,
13726		.hp_nid = 0x03,
13727		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13728		.channel_mode = alc268_modes,
13729		.input_mux = &alc268_capture_source,
13730		.unsol_event = alc268_toshiba_unsol_event,
13731		.setup = alc268_toshiba_setup,
13732		.init_hook = alc268_toshiba_automute,
13733	},
13734	[ALC268_ACER] = {
13735		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13736			    alc268_beep_mixer },
13737		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13738				alc268_acer_verbs },
13739		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13740		.dac_nids = alc268_dac_nids,
13741		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13742		.adc_nids = alc268_adc_nids_alt,
13743		.capsrc_nids = alc268_capsrc_nids,
13744		.hp_nid = 0x02,
13745		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13746		.channel_mode = alc268_modes,
13747		.input_mux = &alc268_acer_capture_source,
13748		.unsol_event = alc268_acer_unsol_event,
13749		.init_hook = alc268_acer_init_hook,
13750	},
13751	[ALC268_ACER_DMIC] = {
13752		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13753			    alc268_beep_mixer },
13754		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13755				alc268_acer_verbs },
13756		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13757		.dac_nids = alc268_dac_nids,
13758		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13759		.adc_nids = alc268_adc_nids_alt,
13760		.capsrc_nids = alc268_capsrc_nids,
13761		.hp_nid = 0x02,
13762		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13763		.channel_mode = alc268_modes,
13764		.input_mux = &alc268_acer_dmic_capture_source,
13765		.unsol_event = alc268_acer_unsol_event,
13766		.init_hook = alc268_acer_init_hook,
13767	},
13768	[ALC268_ACER_ASPIRE_ONE] = {
13769		.mixers = { alc268_acer_aspire_one_mixer,
13770			    alc268_beep_mixer,
13771			    alc268_capture_nosrc_mixer },
13772		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13773				alc268_acer_aspire_one_verbs },
13774		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13775		.dac_nids = alc268_dac_nids,
13776		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13777		.adc_nids = alc268_adc_nids_alt,
13778		.capsrc_nids = alc268_capsrc_nids,
13779		.hp_nid = 0x03,
13780		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13781		.channel_mode = alc268_modes,
13782		.unsol_event = alc268_acer_lc_unsol_event,
13783		.setup = alc268_acer_lc_setup,
13784		.init_hook = alc268_acer_lc_init_hook,
13785	},
13786	[ALC268_DELL] = {
13787		.mixers = { alc268_dell_mixer, alc268_beep_mixer,
13788			    alc268_capture_nosrc_mixer },
13789		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13790				alc268_dell_verbs },
13791		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13792		.dac_nids = alc268_dac_nids,
13793		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13794		.adc_nids = alc268_adc_nids_alt,
13795		.capsrc_nids = alc268_capsrc_nids,
13796		.hp_nid = 0x02,
13797		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13798		.channel_mode = alc268_modes,
13799		.unsol_event = alc_sku_unsol_event,
13800		.setup = alc268_dell_setup,
13801		.init_hook = alc_inithook,
13802	},
13803	[ALC268_ZEPTO] = {
13804		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13805			    alc268_beep_mixer },
13806		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13807				alc268_toshiba_verbs },
13808		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13809		.dac_nids = alc268_dac_nids,
13810		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13811		.adc_nids = alc268_adc_nids_alt,
13812		.capsrc_nids = alc268_capsrc_nids,
13813		.hp_nid = 0x03,
13814		.dig_out_nid = ALC268_DIGOUT_NID,
13815		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13816		.channel_mode = alc268_modes,
13817		.input_mux = &alc268_capture_source,
13818		.setup = alc268_toshiba_setup,
13819		.init_hook = alc268_toshiba_automute,
13820	},
13821#ifdef CONFIG_SND_DEBUG
13822	[ALC268_TEST] = {
13823		.mixers = { alc268_test_mixer, alc268_capture_mixer },
13824		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13825				alc268_volume_init_verbs },
13826		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13827		.dac_nids = alc268_dac_nids,
13828		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13829		.adc_nids = alc268_adc_nids_alt,
13830		.capsrc_nids = alc268_capsrc_nids,
13831		.hp_nid = 0x03,
13832		.dig_out_nid = ALC268_DIGOUT_NID,
13833		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13834		.channel_mode = alc268_modes,
13835		.input_mux = &alc268_capture_source,
13836	},
13837#endif
13838};
13839
13840static int patch_alc268(struct hda_codec *codec)
13841{
13842	struct alc_spec *spec;
13843	int board_config;
13844	int i, has_beep, err;
13845
13846	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13847	if (spec == NULL)
13848		return -ENOMEM;
13849
13850	codec->spec = spec;
13851
13852	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13853						  alc268_models,
13854						  alc268_cfg_tbl);
13855
13856	if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13857		board_config = snd_hda_check_board_codec_sid_config(codec,
13858			ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13859
13860	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13861		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13862		       codec->chip_name);
13863		board_config = ALC268_AUTO;
13864	}
13865
13866	if (board_config == ALC268_AUTO) {
13867		/* automatic parse from the BIOS config */
13868		err = alc268_parse_auto_config(codec);
13869		if (err < 0) {
13870			alc_free(codec);
13871			return err;
13872		} else if (!err) {
13873			printk(KERN_INFO
13874			       "hda_codec: Cannot set up configuration "
13875			       "from BIOS.  Using base mode...\n");
13876			board_config = ALC268_3ST;
13877		}
13878	}
13879
13880	if (board_config != ALC268_AUTO)
13881		setup_preset(codec, &alc268_presets[board_config]);
13882
13883	spec->stream_analog_playback = &alc268_pcm_analog_playback;
13884	spec->stream_analog_capture = &alc268_pcm_analog_capture;
13885	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13886
13887	spec->stream_digital_playback = &alc268_pcm_digital_playback;
13888
13889	has_beep = 0;
13890	for (i = 0; i < spec->num_mixers; i++) {
13891		if (spec->mixers[i] == alc268_beep_mixer) {
13892			has_beep = 1;
13893			break;
13894		}
13895	}
13896
13897	if (has_beep) {
13898		err = snd_hda_attach_beep_device(codec, 0x1);
13899		if (err < 0) {
13900			alc_free(codec);
13901			return err;
13902		}
13903		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13904			/* override the amp caps for beep generator */
13905			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13906					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13907					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13908					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13909					  (0 << AC_AMPCAP_MUTE_SHIFT));
13910	}
13911
13912	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13913		/* check whether NID 0x07 is valid */
13914		unsigned int wcap = get_wcaps(codec, 0x07);
13915		int i;
13916
13917		spec->capsrc_nids = alc268_capsrc_nids;
13918		/* get type */
13919		wcap = get_wcaps_type(wcap);
13920		if (spec->auto_mic ||
13921		    wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13922			spec->adc_nids = alc268_adc_nids_alt;
13923			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13924			if (spec->auto_mic)
13925				fixup_automic_adc(codec);
13926			if (spec->auto_mic || spec->input_mux->num_items == 1)
13927				add_mixer(spec, alc268_capture_nosrc_mixer);
13928			else
13929				add_mixer(spec, alc268_capture_alt_mixer);
13930		} else {
13931			spec->adc_nids = alc268_adc_nids;
13932			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13933			add_mixer(spec, alc268_capture_mixer);
13934		}
13935		/* set default input source */
13936		for (i = 0; i < spec->num_adc_nids; i++)
13937			snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13938				0, AC_VERB_SET_CONNECT_SEL,
13939				i < spec->num_mux_defs ?
13940				spec->input_mux[i].items[0].index :
13941				spec->input_mux->items[0].index);
13942	}
13943
13944	spec->vmaster_nid = 0x02;
13945
13946	codec->patch_ops = alc_patch_ops;
13947	if (board_config == ALC268_AUTO)
13948		spec->init_hook = alc268_auto_init;
13949
13950	return 0;
13951}
13952
13953/*
13954 *  ALC269 channel source setting (2 channel)
13955 */
13956#define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
13957
13958#define alc269_dac_nids		alc260_dac_nids
13959
13960static hda_nid_t alc269_adc_nids[1] = {
13961	/* ADC1 */
13962	0x08,
13963};
13964
13965static hda_nid_t alc269_capsrc_nids[1] = {
13966	0x23,
13967};
13968
13969static hda_nid_t alc269vb_adc_nids[1] = {
13970	/* ADC1 */
13971	0x09,
13972};
13973
13974static hda_nid_t alc269vb_capsrc_nids[1] = {
13975	0x22,
13976};
13977
13978static hda_nid_t alc269_adc_candidates[] = {
13979	0x08, 0x09, 0x07,
13980};
13981
13982#define alc269_modes		alc260_modes
13983#define alc269_capture_source	alc880_lg_lw_capture_source
13984
13985static struct snd_kcontrol_new alc269_base_mixer[] = {
13986	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13987	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13988	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13989	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13990	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13991	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13992	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13993	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13994	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13995	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13996	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13997	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13998	{ } /* end */
13999};
14000
14001static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14002	/* output mixer control */
14003	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14004	{
14005		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14006		.name = "Master Playback Switch",
14007		.subdevice = HDA_SUBDEV_AMP_FLAG,
14008		.info = snd_hda_mixer_amp_switch_info,
14009		.get = snd_hda_mixer_amp_switch_get,
14010		.put = alc268_acer_master_sw_put,
14011		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14012	},
14013	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14014	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14015	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14016	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14017	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14018	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14019	{ }
14020};
14021
14022static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14023	/* output mixer control */
14024	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14025	{
14026		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14027		.name = "Master Playback Switch",
14028		.subdevice = HDA_SUBDEV_AMP_FLAG,
14029		.info = snd_hda_mixer_amp_switch_info,
14030		.get = snd_hda_mixer_amp_switch_get,
14031		.put = alc268_acer_master_sw_put,
14032		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14033	},
14034	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14035	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14036	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14037	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14038	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14039	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14040	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14041	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14042	HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
14043	{ }
14044};
14045
14046static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14047	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14048	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14049	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14050	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14051	{ } /* end */
14052};
14053
14054static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14055	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14056	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14057	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14058	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14059	{ } /* end */
14060};
14061
14062static struct snd_kcontrol_new alc269_asus_mixer[] = {
14063	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14064	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14065	{ } /* end */
14066};
14067
14068/* capture mixer elements */
14069static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14070	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14071	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14072	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14073	HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14074	{ } /* end */
14075};
14076
14077static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14078	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14079	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14080	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14081	{ } /* end */
14082};
14083
14084static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14085	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14086	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14087	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14088	HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14089	{ } /* end */
14090};
14091
14092static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14093	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14094	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14095	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14096	{ } /* end */
14097};
14098
14099/* FSC amilo */
14100#define alc269_fujitsu_mixer	alc269_laptop_mixer
14101
14102static struct hda_verb alc269_quanta_fl1_verbs[] = {
14103	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14104	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14105	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14106	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14107	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14108	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14109	{ }
14110};
14111
14112static struct hda_verb alc269_lifebook_verbs[] = {
14113	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14114	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14115	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14116	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14117	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14118	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14119	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14120	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14121	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14122	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14123	{ }
14124};
14125
14126/* toggle speaker-output according to the hp-jack state */
14127static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14128{
14129	unsigned int present;
14130	unsigned char bits;
14131
14132	present = snd_hda_jack_detect(codec, 0x15);
14133	bits = present ? HDA_AMP_MUTE : 0;
14134	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14135				 HDA_AMP_MUTE, bits);
14136	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14137				 HDA_AMP_MUTE, bits);
14138
14139	snd_hda_codec_write(codec, 0x20, 0,
14140			AC_VERB_SET_COEF_INDEX, 0x0c);
14141	snd_hda_codec_write(codec, 0x20, 0,
14142			AC_VERB_SET_PROC_COEF, 0x680);
14143
14144	snd_hda_codec_write(codec, 0x20, 0,
14145			AC_VERB_SET_COEF_INDEX, 0x0c);
14146	snd_hda_codec_write(codec, 0x20, 0,
14147			AC_VERB_SET_PROC_COEF, 0x480);
14148}
14149
14150/* toggle speaker-output according to the hp-jacks state */
14151static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14152{
14153	unsigned int present;
14154	unsigned char bits;
14155
14156	/* Check laptop headphone socket */
14157	present = snd_hda_jack_detect(codec, 0x15);
14158
14159	/* Check port replicator headphone socket */
14160	present |= snd_hda_jack_detect(codec, 0x1a);
14161
14162	bits = present ? HDA_AMP_MUTE : 0;
14163	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14164				 HDA_AMP_MUTE, bits);
14165	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14166				 HDA_AMP_MUTE, bits);
14167
14168	snd_hda_codec_write(codec, 0x20, 0,
14169			AC_VERB_SET_COEF_INDEX, 0x0c);
14170	snd_hda_codec_write(codec, 0x20, 0,
14171			AC_VERB_SET_PROC_COEF, 0x680);
14172
14173	snd_hda_codec_write(codec, 0x20, 0,
14174			AC_VERB_SET_COEF_INDEX, 0x0c);
14175	snd_hda_codec_write(codec, 0x20, 0,
14176			AC_VERB_SET_PROC_COEF, 0x480);
14177}
14178
14179static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14180{
14181	unsigned int present_laptop;
14182	unsigned int present_dock;
14183
14184	present_laptop	= snd_hda_jack_detect(codec, 0x18);
14185	present_dock	= snd_hda_jack_detect(codec, 0x1b);
14186
14187	/* Laptop mic port overrides dock mic port, design decision */
14188	if (present_dock)
14189		snd_hda_codec_write(codec, 0x23, 0,
14190				AC_VERB_SET_CONNECT_SEL, 0x3);
14191	if (present_laptop)
14192		snd_hda_codec_write(codec, 0x23, 0,
14193				AC_VERB_SET_CONNECT_SEL, 0x0);
14194	if (!present_dock && !present_laptop)
14195		snd_hda_codec_write(codec, 0x23, 0,
14196				AC_VERB_SET_CONNECT_SEL, 0x1);
14197}
14198
14199static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14200				    unsigned int res)
14201{
14202	switch (res >> 26) {
14203	case ALC880_HP_EVENT:
14204		alc269_quanta_fl1_speaker_automute(codec);
14205		break;
14206	case ALC880_MIC_EVENT:
14207		alc_mic_automute(codec);
14208		break;
14209	}
14210}
14211
14212static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14213					unsigned int res)
14214{
14215	if ((res >> 26) == ALC880_HP_EVENT)
14216		alc269_lifebook_speaker_automute(codec);
14217	if ((res >> 26) == ALC880_MIC_EVENT)
14218		alc269_lifebook_mic_autoswitch(codec);
14219}
14220
14221static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14222{
14223	struct alc_spec *spec = codec->spec;
14224	spec->autocfg.hp_pins[0] = 0x15;
14225	spec->autocfg.speaker_pins[0] = 0x14;
14226	spec->ext_mic.pin = 0x18;
14227	spec->ext_mic.mux_idx = 0;
14228	spec->int_mic.pin = 0x19;
14229	spec->int_mic.mux_idx = 1;
14230	spec->auto_mic = 1;
14231}
14232
14233static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14234{
14235	alc269_quanta_fl1_speaker_automute(codec);
14236	alc_mic_automute(codec);
14237}
14238
14239static void alc269_lifebook_init_hook(struct hda_codec *codec)
14240{
14241	alc269_lifebook_speaker_automute(codec);
14242	alc269_lifebook_mic_autoswitch(codec);
14243}
14244
14245static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14246	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14247	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14248	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14249	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14250	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14251	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14252	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14253	{}
14254};
14255
14256static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14257	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14258	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14259	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14260	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14261	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14262	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14263	{}
14264};
14265
14266static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14267	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14268	{0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14269	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14270	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14271	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14272	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14273	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14274	{}
14275};
14276
14277static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14278	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14279	{0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14280	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14281	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14282	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14283	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14284	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14285	{}
14286};
14287
14288static struct hda_verb alc271_acer_dmic_verbs[] = {
14289	{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14290	{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14291	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14292	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14293	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14294	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14295	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14296	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14297	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14298	{0x22, AC_VERB_SET_CONNECT_SEL, 6},
14299	{ }
14300};
14301
14302/* toggle speaker-output according to the hp-jack state */
14303static void alc269_speaker_automute(struct hda_codec *codec)
14304{
14305	struct alc_spec *spec = codec->spec;
14306	unsigned int nid = spec->autocfg.hp_pins[0];
14307	unsigned int present;
14308	unsigned char bits;
14309
14310	present = snd_hda_jack_detect(codec, nid);
14311	bits = present ? HDA_AMP_MUTE : 0;
14312	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14313				 HDA_AMP_MUTE, bits);
14314	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14315				 HDA_AMP_MUTE, bits);
14316}
14317
14318/* unsolicited event for HP jack sensing */
14319static void alc269_laptop_unsol_event(struct hda_codec *codec,
14320				     unsigned int res)
14321{
14322	switch (res >> 26) {
14323	case ALC880_HP_EVENT:
14324		alc269_speaker_automute(codec);
14325		break;
14326	case ALC880_MIC_EVENT:
14327		alc_mic_automute(codec);
14328		break;
14329	}
14330}
14331
14332static void alc269_laptop_amic_setup(struct hda_codec *codec)
14333{
14334	struct alc_spec *spec = codec->spec;
14335	spec->autocfg.hp_pins[0] = 0x15;
14336	spec->autocfg.speaker_pins[0] = 0x14;
14337	spec->ext_mic.pin = 0x18;
14338	spec->ext_mic.mux_idx = 0;
14339	spec->int_mic.pin = 0x19;
14340	spec->int_mic.mux_idx = 1;
14341	spec->auto_mic = 1;
14342}
14343
14344static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14345{
14346	struct alc_spec *spec = codec->spec;
14347	spec->autocfg.hp_pins[0] = 0x15;
14348	spec->autocfg.speaker_pins[0] = 0x14;
14349	spec->ext_mic.pin = 0x18;
14350	spec->ext_mic.mux_idx = 0;
14351	spec->int_mic.pin = 0x12;
14352	spec->int_mic.mux_idx = 5;
14353	spec->auto_mic = 1;
14354}
14355
14356static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14357{
14358	struct alc_spec *spec = codec->spec;
14359	spec->autocfg.hp_pins[0] = 0x21;
14360	spec->autocfg.speaker_pins[0] = 0x14;
14361	spec->ext_mic.pin = 0x18;
14362	spec->ext_mic.mux_idx = 0;
14363	spec->int_mic.pin = 0x19;
14364	spec->int_mic.mux_idx = 1;
14365	spec->auto_mic = 1;
14366}
14367
14368static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14369{
14370	struct alc_spec *spec = codec->spec;
14371	spec->autocfg.hp_pins[0] = 0x21;
14372	spec->autocfg.speaker_pins[0] = 0x14;
14373	spec->ext_mic.pin = 0x18;
14374	spec->ext_mic.mux_idx = 0;
14375	spec->int_mic.pin = 0x12;
14376	spec->int_mic.mux_idx = 6;
14377	spec->auto_mic = 1;
14378}
14379
14380static void alc269_laptop_inithook(struct hda_codec *codec)
14381{
14382	alc269_speaker_automute(codec);
14383	alc_mic_automute(codec);
14384}
14385
14386/*
14387 * generic initialization of ADC, input mixers and output mixers
14388 */
14389static struct hda_verb alc269_init_verbs[] = {
14390	/*
14391	 * Unmute ADC0 and set the default input to mic-in
14392	 */
14393	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14394
14395	/*
14396	 * Set up output mixers (0x02 - 0x03)
14397	 */
14398	/* set vol=0 to output mixers */
14399	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14400	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14401
14402	/* set up input amps for analog loopback */
14403	/* Amp Indices: DAC = 0, mixer = 1 */
14404	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14405	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14406	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14407	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14408	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14409	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14410
14411	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14412	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14413	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14414	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14415	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14416	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14417	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14418
14419	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14420	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14421
14422	/* FIXME: use Mux-type input source selection */
14423	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14424	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14425	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14426
14427	/* set EAPD */
14428	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14429	{ }
14430};
14431
14432static struct hda_verb alc269vb_init_verbs[] = {
14433	/*
14434	 * Unmute ADC0 and set the default input to mic-in
14435	 */
14436	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14437
14438	/*
14439	 * Set up output mixers (0x02 - 0x03)
14440	 */
14441	/* set vol=0 to output mixers */
14442	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14443	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14444
14445	/* set up input amps for analog loopback */
14446	/* Amp Indices: DAC = 0, mixer = 1 */
14447	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14448	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14449	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14450	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14451	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14452	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14453
14454	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14455	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14456	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14457	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14458	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14459	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14460	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14461
14462	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14463	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14464
14465	/* FIXME: use Mux-type input source selection */
14466	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14467	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14468	{0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14469
14470	/* set EAPD */
14471	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14472	{ }
14473};
14474
14475#define alc269_auto_create_multi_out_ctls \
14476	alc268_auto_create_multi_out_ctls
14477#define alc269_auto_create_input_ctls \
14478	alc268_auto_create_input_ctls
14479
14480#ifdef CONFIG_SND_HDA_POWER_SAVE
14481#define alc269_loopbacks	alc880_loopbacks
14482#endif
14483
14484/* pcm configuration: identical with ALC880 */
14485#define alc269_pcm_analog_playback	alc880_pcm_analog_playback
14486#define alc269_pcm_analog_capture	alc880_pcm_analog_capture
14487#define alc269_pcm_digital_playback	alc880_pcm_digital_playback
14488#define alc269_pcm_digital_capture	alc880_pcm_digital_capture
14489
14490static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14491	.substreams = 1,
14492	.channels_min = 2,
14493	.channels_max = 8,
14494	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14495	/* NID is set in alc_build_pcms */
14496	.ops = {
14497		.open = alc880_playback_pcm_open,
14498		.prepare = alc880_playback_pcm_prepare,
14499		.cleanup = alc880_playback_pcm_cleanup
14500	},
14501};
14502
14503static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14504	.substreams = 1,
14505	.channels_min = 2,
14506	.channels_max = 2,
14507	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14508	/* NID is set in alc_build_pcms */
14509};
14510
14511#ifdef CONFIG_SND_HDA_POWER_SAVE
14512static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14513{
14514	switch (codec->subsystem_id) {
14515	case 0x103c1586:
14516		return 1;
14517	}
14518	return 0;
14519}
14520
14521static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14522{
14523	/* update mute-LED according to the speaker mute state */
14524	if (nid == 0x01 || nid == 0x14) {
14525		int pinval;
14526		if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14527		    HDA_AMP_MUTE)
14528			pinval = 0x24;
14529		else
14530			pinval = 0x20;
14531		/* mic2 vref pin is used for mute LED control */
14532		snd_hda_codec_update_cache(codec, 0x19, 0,
14533					   AC_VERB_SET_PIN_WIDGET_CONTROL,
14534					   pinval);
14535	}
14536	return alc_check_power_status(codec, nid);
14537}
14538#endif /* CONFIG_SND_HDA_POWER_SAVE */
14539
14540static int alc275_setup_dual_adc(struct hda_codec *codec)
14541{
14542	struct alc_spec *spec = codec->spec;
14543
14544	if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14545		return 0;
14546	if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14547	    (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14548		if (spec->ext_mic.pin <= 0x12) {
14549			spec->private_adc_nids[0] = 0x08;
14550			spec->private_adc_nids[1] = 0x11;
14551			spec->private_capsrc_nids[0] = 0x23;
14552			spec->private_capsrc_nids[1] = 0x22;
14553		} else {
14554			spec->private_adc_nids[0] = 0x11;
14555			spec->private_adc_nids[1] = 0x08;
14556			spec->private_capsrc_nids[0] = 0x22;
14557			spec->private_capsrc_nids[1] = 0x23;
14558		}
14559		spec->adc_nids = spec->private_adc_nids;
14560		spec->capsrc_nids = spec->private_capsrc_nids;
14561		spec->num_adc_nids = 2;
14562		spec->dual_adc_switch = 1;
14563		snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14564			    spec->adc_nids[0], spec->adc_nids[1]);
14565		return 1;
14566	}
14567	return 0;
14568}
14569
14570/* different alc269-variants */
14571enum {
14572	ALC269_TYPE_NORMAL,
14573	ALC269_TYPE_ALC259,
14574	ALC269_TYPE_ALC271X,
14575};
14576
14577/*
14578 * BIOS auto configuration
14579 */
14580static int alc269_parse_auto_config(struct hda_codec *codec)
14581{
14582	struct alc_spec *spec = codec->spec;
14583	int err;
14584	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14585
14586	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14587					   alc269_ignore);
14588	if (err < 0)
14589		return err;
14590
14591	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14592	if (err < 0)
14593		return err;
14594	if (spec->codec_variant == ALC269_TYPE_NORMAL)
14595		err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14596	else
14597		err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14598						 0x22, 0);
14599	if (err < 0)
14600		return err;
14601
14602	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14603
14604	alc_auto_parse_digital(codec);
14605
14606	if (spec->kctls.list)
14607		add_mixer(spec, spec->kctls.list);
14608
14609	if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14610		add_verb(spec, alc269vb_init_verbs);
14611		alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14612	} else {
14613		add_verb(spec, alc269_init_verbs);
14614		alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14615	}
14616
14617	spec->num_mux_defs = 1;
14618	spec->input_mux = &spec->private_imux[0];
14619
14620	if (!alc275_setup_dual_adc(codec))
14621		fillup_priv_adc_nids(codec, alc269_adc_candidates,
14622				     sizeof(alc269_adc_candidates));
14623
14624	/* set default input source */
14625	if (!spec->dual_adc_switch)
14626		select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14627					spec->input_mux->items[0].index);
14628
14629	err = alc_auto_add_mic_boost(codec);
14630	if (err < 0)
14631		return err;
14632
14633	if (!spec->cap_mixer && !spec->no_analog)
14634		set_capture_mixer(codec);
14635
14636	return 1;
14637}
14638
14639#define alc269_auto_init_multi_out	alc268_auto_init_multi_out
14640#define alc269_auto_init_hp_out		alc268_auto_init_hp_out
14641#define alc269_auto_init_analog_input	alc882_auto_init_analog_input
14642
14643
14644/* init callback for auto-configuration model -- overriding the default init */
14645static void alc269_auto_init(struct hda_codec *codec)
14646{
14647	struct alc_spec *spec = codec->spec;
14648	alc269_auto_init_multi_out(codec);
14649	alc269_auto_init_hp_out(codec);
14650	alc269_auto_init_analog_input(codec);
14651	alc_auto_init_digital(codec);
14652	alc_init_jacks(codec);
14653	if (spec->unsol_event)
14654		alc_inithook(codec);
14655}
14656
14657#ifdef SND_HDA_NEEDS_RESUME
14658static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14659{
14660	int val = alc_read_coef_idx(codec, 0x04);
14661	if (power_up)
14662		val |= 1 << 11;
14663	else
14664		val &= ~(1 << 11);
14665	alc_write_coef_idx(codec, 0x04, val);
14666}
14667
14668#ifdef CONFIG_SND_HDA_POWER_SAVE
14669static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14670{
14671	struct alc_spec *spec = codec->spec;
14672
14673	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14674		alc269_toggle_power_output(codec, 0);
14675	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14676		alc269_toggle_power_output(codec, 0);
14677		msleep(150);
14678	}
14679
14680	alc_shutup(codec);
14681	if (spec && spec->power_hook)
14682		spec->power_hook(codec);
14683	return 0;
14684}
14685#endif /* CONFIG_SND_HDA_POWER_SAVE */
14686
14687static int alc269_resume(struct hda_codec *codec)
14688{
14689	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14690		alc269_toggle_power_output(codec, 0);
14691		msleep(150);
14692	}
14693
14694	codec->patch_ops.init(codec);
14695
14696	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14697		alc269_toggle_power_output(codec, 1);
14698		msleep(200);
14699	}
14700
14701	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14702		alc269_toggle_power_output(codec, 1);
14703
14704	snd_hda_codec_resume_amp(codec);
14705	snd_hda_codec_resume_cache(codec);
14706	hda_call_check_power_status(codec, 0x01);
14707	return 0;
14708}
14709#endif /* SND_HDA_NEEDS_RESUME */
14710
14711enum {
14712	ALC269_FIXUP_SONY_VAIO,
14713};
14714
14715static const struct alc_fixup alc269_fixups[] = {
14716	[ALC269_FIXUP_SONY_VAIO] = {
14717		.verbs = (const struct hda_verb[]) {
14718			{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14719			{}
14720		}
14721	},
14722};
14723
14724static struct snd_pci_quirk alc269_fixup_tbl[] = {
14725	SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14726	SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14727	{}
14728};
14729
14730
14731/*
14732 * configuration and preset
14733 */
14734static const char *alc269_models[ALC269_MODEL_LAST] = {
14735	[ALC269_BASIC]			= "basic",
14736	[ALC269_QUANTA_FL1]		= "quanta",
14737	[ALC269_AMIC]			= "laptop-amic",
14738	[ALC269_DMIC]			= "laptop-dmic",
14739	[ALC269_FUJITSU]		= "fujitsu",
14740	[ALC269_LIFEBOOK]		= "lifebook",
14741	[ALC269_AUTO]			= "auto",
14742};
14743
14744static struct snd_pci_quirk alc269_cfg_tbl[] = {
14745	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14746	SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14747	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14748		      ALC269_AMIC),
14749	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14750	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14751	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14752	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14753	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14754	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14755	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14756	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14757	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14758	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14759	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14760	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14761	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14762	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14763	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14764	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14765	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14766	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14767	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14768	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14769	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14770	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14771	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14772	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14773	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14774	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14775	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14776	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14777	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14778	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14779	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14780	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14781	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14782	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14783	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14784	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14785	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14786		      ALC269_DMIC),
14787	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14788		      ALC269_DMIC),
14789	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14790	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14791	SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14792	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14793	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14794	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14795	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14796	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14797	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14798	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14799	{}
14800};
14801
14802static struct alc_config_preset alc269_presets[] = {
14803	[ALC269_BASIC] = {
14804		.mixers = { alc269_base_mixer },
14805		.init_verbs = { alc269_init_verbs },
14806		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14807		.dac_nids = alc269_dac_nids,
14808		.hp_nid = 0x03,
14809		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14810		.channel_mode = alc269_modes,
14811		.input_mux = &alc269_capture_source,
14812	},
14813	[ALC269_QUANTA_FL1] = {
14814		.mixers = { alc269_quanta_fl1_mixer },
14815		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14816		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14817		.dac_nids = alc269_dac_nids,
14818		.hp_nid = 0x03,
14819		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14820		.channel_mode = alc269_modes,
14821		.input_mux = &alc269_capture_source,
14822		.unsol_event = alc269_quanta_fl1_unsol_event,
14823		.setup = alc269_quanta_fl1_setup,
14824		.init_hook = alc269_quanta_fl1_init_hook,
14825	},
14826	[ALC269_AMIC] = {
14827		.mixers = { alc269_laptop_mixer },
14828		.cap_mixer = alc269_laptop_analog_capture_mixer,
14829		.init_verbs = { alc269_init_verbs,
14830				alc269_laptop_amic_init_verbs },
14831		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14832		.dac_nids = alc269_dac_nids,
14833		.hp_nid = 0x03,
14834		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14835		.channel_mode = alc269_modes,
14836		.unsol_event = alc269_laptop_unsol_event,
14837		.setup = alc269_laptop_amic_setup,
14838		.init_hook = alc269_laptop_inithook,
14839	},
14840	[ALC269_DMIC] = {
14841		.mixers = { alc269_laptop_mixer },
14842		.cap_mixer = alc269_laptop_digital_capture_mixer,
14843		.init_verbs = { alc269_init_verbs,
14844				alc269_laptop_dmic_init_verbs },
14845		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14846		.dac_nids = alc269_dac_nids,
14847		.hp_nid = 0x03,
14848		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14849		.channel_mode = alc269_modes,
14850		.unsol_event = alc269_laptop_unsol_event,
14851		.setup = alc269_laptop_dmic_setup,
14852		.init_hook = alc269_laptop_inithook,
14853	},
14854	[ALC269VB_AMIC] = {
14855		.mixers = { alc269vb_laptop_mixer },
14856		.cap_mixer = alc269vb_laptop_analog_capture_mixer,
14857		.init_verbs = { alc269vb_init_verbs,
14858				alc269vb_laptop_amic_init_verbs },
14859		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14860		.dac_nids = alc269_dac_nids,
14861		.hp_nid = 0x03,
14862		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14863		.channel_mode = alc269_modes,
14864		.unsol_event = alc269_laptop_unsol_event,
14865		.setup = alc269vb_laptop_amic_setup,
14866		.init_hook = alc269_laptop_inithook,
14867	},
14868	[ALC269VB_DMIC] = {
14869		.mixers = { alc269vb_laptop_mixer },
14870		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
14871		.init_verbs = { alc269vb_init_verbs,
14872				alc269vb_laptop_dmic_init_verbs },
14873		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14874		.dac_nids = alc269_dac_nids,
14875		.hp_nid = 0x03,
14876		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14877		.channel_mode = alc269_modes,
14878		.unsol_event = alc269_laptop_unsol_event,
14879		.setup = alc269vb_laptop_dmic_setup,
14880		.init_hook = alc269_laptop_inithook,
14881	},
14882	[ALC269_FUJITSU] = {
14883		.mixers = { alc269_fujitsu_mixer },
14884		.cap_mixer = alc269_laptop_digital_capture_mixer,
14885		.init_verbs = { alc269_init_verbs,
14886				alc269_laptop_dmic_init_verbs },
14887		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14888		.dac_nids = alc269_dac_nids,
14889		.hp_nid = 0x03,
14890		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14891		.channel_mode = alc269_modes,
14892		.unsol_event = alc269_laptop_unsol_event,
14893		.setup = alc269_laptop_dmic_setup,
14894		.init_hook = alc269_laptop_inithook,
14895	},
14896	[ALC269_LIFEBOOK] = {
14897		.mixers = { alc269_lifebook_mixer },
14898		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14899		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14900		.dac_nids = alc269_dac_nids,
14901		.hp_nid = 0x03,
14902		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14903		.channel_mode = alc269_modes,
14904		.input_mux = &alc269_capture_source,
14905		.unsol_event = alc269_lifebook_unsol_event,
14906		.init_hook = alc269_lifebook_init_hook,
14907	},
14908	[ALC271_ACER] = {
14909		.mixers = { alc269_asus_mixer },
14910		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
14911		.init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
14912		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14913		.dac_nids = alc269_dac_nids,
14914		.adc_nids = alc262_dmic_adc_nids,
14915		.num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
14916		.capsrc_nids = alc262_dmic_capsrc_nids,
14917		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14918		.channel_mode = alc269_modes,
14919		.input_mux = &alc269_capture_source,
14920		.dig_out_nid = ALC880_DIGOUT_NID,
14921		.unsol_event = alc_sku_unsol_event,
14922		.setup = alc269vb_laptop_dmic_setup,
14923		.init_hook = alc_inithook,
14924	},
14925};
14926
14927static int alc269_fill_coef(struct hda_codec *codec)
14928{
14929	int val;
14930
14931	if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
14932		alc_write_coef_idx(codec, 0xf, 0x960b);
14933		alc_write_coef_idx(codec, 0xe, 0x8817);
14934	}
14935
14936	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
14937		alc_write_coef_idx(codec, 0xf, 0x960b);
14938		alc_write_coef_idx(codec, 0xe, 0x8814);
14939	}
14940
14941	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14942		val = alc_read_coef_idx(codec, 0x04);
14943		/* Power up output pin */
14944		alc_write_coef_idx(codec, 0x04, val | (1<<11));
14945	}
14946
14947	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14948		val = alc_read_coef_idx(codec, 0xd);
14949		if ((val & 0x0c00) >> 10 != 0x1) {
14950			/* Capless ramp up clock control */
14951			alc_write_coef_idx(codec, 0xd, val | 1<<10);
14952		}
14953		val = alc_read_coef_idx(codec, 0x17);
14954		if ((val & 0x01c0) >> 6 != 0x4) {
14955			/* Class D power on reset */
14956			alc_write_coef_idx(codec, 0x17, val | 1<<7);
14957		}
14958	}
14959	return 0;
14960}
14961
14962static int patch_alc269(struct hda_codec *codec)
14963{
14964	struct alc_spec *spec;
14965	int board_config;
14966	int err;
14967
14968	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14969	if (spec == NULL)
14970		return -ENOMEM;
14971
14972	codec->spec = spec;
14973
14974	alc_auto_parse_customize_define(codec);
14975
14976	if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14977		if (codec->bus->pci->subsystem_vendor == 0x1025 &&
14978		    spec->cdefine.platform_type == 1) {
14979			alc_codec_rename(codec, "ALC271X");
14980			spec->codec_variant = ALC269_TYPE_ALC271X;
14981		} else {
14982			alc_codec_rename(codec, "ALC259");
14983			spec->codec_variant = ALC269_TYPE_ALC259;
14984		}
14985	} else
14986		alc_fix_pll_init(codec, 0x20, 0x04, 15);
14987
14988	alc269_fill_coef(codec);
14989
14990	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14991						  alc269_models,
14992						  alc269_cfg_tbl);
14993
14994	if (board_config < 0) {
14995		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14996		       codec->chip_name);
14997		board_config = ALC269_AUTO;
14998	}
14999
15000	if (board_config == ALC269_AUTO)
15001		alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
15002
15003	if (board_config == ALC269_AUTO) {
15004		/* automatic parse from the BIOS config */
15005		err = alc269_parse_auto_config(codec);
15006		if (err < 0) {
15007			alc_free(codec);
15008			return err;
15009		} else if (!err) {
15010			printk(KERN_INFO
15011			       "hda_codec: Cannot set up configuration "
15012			       "from BIOS.  Using base mode...\n");
15013			board_config = ALC269_BASIC;
15014		}
15015	}
15016
15017	if (has_cdefine_beep(codec)) {
15018		err = snd_hda_attach_beep_device(codec, 0x1);
15019		if (err < 0) {
15020			alc_free(codec);
15021			return err;
15022		}
15023	}
15024
15025	if (board_config != ALC269_AUTO)
15026		setup_preset(codec, &alc269_presets[board_config]);
15027
15028	if (board_config == ALC269_QUANTA_FL1) {
15029		/* Due to a hardware problem on Lenovo Ideadpad, we need to
15030		 * fix the sample rate of analog I/O to 44.1kHz
15031		 */
15032		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15033		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15034	} else if (spec->dual_adc_switch) {
15035		spec->stream_analog_playback = &alc269_pcm_analog_playback;
15036		/* switch ADC dynamically */
15037		spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15038	} else {
15039		spec->stream_analog_playback = &alc269_pcm_analog_playback;
15040		spec->stream_analog_capture = &alc269_pcm_analog_capture;
15041	}
15042	spec->stream_digital_playback = &alc269_pcm_digital_playback;
15043	spec->stream_digital_capture = &alc269_pcm_digital_capture;
15044
15045	if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15046		if (spec->codec_variant != ALC269_TYPE_NORMAL) {
15047			spec->adc_nids = alc269_adc_nids;
15048			spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15049			spec->capsrc_nids = alc269_capsrc_nids;
15050		} else {
15051			spec->adc_nids = alc269vb_adc_nids;
15052			spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15053			spec->capsrc_nids = alc269vb_capsrc_nids;
15054		}
15055	}
15056
15057	if (!spec->cap_mixer)
15058		set_capture_mixer(codec);
15059	if (has_cdefine_beep(codec))
15060		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15061
15062	if (board_config == ALC269_AUTO)
15063		alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
15064
15065	spec->vmaster_nid = 0x02;
15066
15067	codec->patch_ops = alc_patch_ops;
15068#ifdef CONFIG_SND_HDA_POWER_SAVE
15069	codec->patch_ops.suspend = alc269_suspend;
15070#endif
15071#ifdef SND_HDA_NEEDS_RESUME
15072	codec->patch_ops.resume = alc269_resume;
15073#endif
15074	if (board_config == ALC269_AUTO)
15075		spec->init_hook = alc269_auto_init;
15076#ifdef CONFIG_SND_HDA_POWER_SAVE
15077	if (!spec->loopback.amplist)
15078		spec->loopback.amplist = alc269_loopbacks;
15079	if (alc269_mic2_for_mute_led(codec))
15080		codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15081#endif
15082
15083	return 0;
15084}
15085
15086/*
15087 *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15088 */
15089
15090/*
15091 * set the path ways for 2 channel output
15092 * need to set the codec line out and mic 1 pin widgets to inputs
15093 */
15094static struct hda_verb alc861_threestack_ch2_init[] = {
15095	/* set pin widget 1Ah (line in) for input */
15096	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15097	/* set pin widget 18h (mic1/2) for input, for mic also enable
15098	 * the vref
15099	 */
15100	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15101
15102	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15103#if 0
15104	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15105	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15106#endif
15107	{ } /* end */
15108};
15109/*
15110 * 6ch mode
15111 * need to set the codec line out and mic 1 pin widgets to outputs
15112 */
15113static struct hda_verb alc861_threestack_ch6_init[] = {
15114	/* set pin widget 1Ah (line in) for output (Back Surround)*/
15115	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15116	/* set pin widget 18h (mic1) for output (CLFE)*/
15117	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15118
15119	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15120	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15121
15122	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15123#if 0
15124	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15125	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15126#endif
15127	{ } /* end */
15128};
15129
15130static struct hda_channel_mode alc861_threestack_modes[2] = {
15131	{ 2, alc861_threestack_ch2_init },
15132	{ 6, alc861_threestack_ch6_init },
15133};
15134/* Set mic1 as input and unmute the mixer */
15135static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15136	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15137	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15138	{ } /* end */
15139};
15140/* Set mic1 as output and mute mixer */
15141static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15142	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15143	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15144	{ } /* end */
15145};
15146
15147static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15148	{ 2, alc861_uniwill_m31_ch2_init },
15149	{ 4, alc861_uniwill_m31_ch4_init },
15150};
15151
15152/* Set mic1 and line-in as input and unmute the mixer */
15153static struct hda_verb alc861_asus_ch2_init[] = {
15154	/* set pin widget 1Ah (line in) for input */
15155	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15156	/* set pin widget 18h (mic1/2) for input, for mic also enable
15157	 * the vref
15158	 */
15159	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15160
15161	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15162#if 0
15163	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15164	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15165#endif
15166	{ } /* end */
15167};
15168/* Set mic1 nad line-in as output and mute mixer */
15169static struct hda_verb alc861_asus_ch6_init[] = {
15170	/* set pin widget 1Ah (line in) for output (Back Surround)*/
15171	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15172	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15173	/* set pin widget 18h (mic1) for output (CLFE)*/
15174	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15175	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15176	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15177	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15178
15179	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15180#if 0
15181	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15182	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15183#endif
15184	{ } /* end */
15185};
15186
15187static struct hda_channel_mode alc861_asus_modes[2] = {
15188	{ 2, alc861_asus_ch2_init },
15189	{ 6, alc861_asus_ch6_init },
15190};
15191
15192/* patch-ALC861 */
15193
15194static struct snd_kcontrol_new alc861_base_mixer[] = {
15195        /* output mixer control */
15196	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15197	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15198	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15199	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15200	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15201
15202        /*Input mixer control */
15203	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15204	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15205	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15206	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15207	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15208	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15209	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15210	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15211	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15212	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15213
15214	{ } /* end */
15215};
15216
15217static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15218        /* output mixer control */
15219	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15220	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15221	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15222	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15223	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15224
15225	/* Input mixer control */
15226	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15227	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15228	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15229	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15230	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15231	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15232	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15233	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15234	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15235	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15236
15237	{
15238		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15239		.name = "Channel Mode",
15240		.info = alc_ch_mode_info,
15241		.get = alc_ch_mode_get,
15242		.put = alc_ch_mode_put,
15243                .private_value = ARRAY_SIZE(alc861_threestack_modes),
15244	},
15245	{ } /* end */
15246};
15247
15248static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15249        /* output mixer control */
15250	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15251	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15252	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15253
15254	{ } /* end */
15255};
15256
15257static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15258        /* output mixer control */
15259	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15260	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15261	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15262	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15263	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15264
15265	/* Input mixer control */
15266	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15267	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15268	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15269	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15270	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15271	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15272	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15273	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15274	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15275	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15276
15277	{
15278		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15279		.name = "Channel Mode",
15280		.info = alc_ch_mode_info,
15281		.get = alc_ch_mode_get,
15282		.put = alc_ch_mode_put,
15283                .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15284	},
15285	{ } /* end */
15286};
15287
15288static struct snd_kcontrol_new alc861_asus_mixer[] = {
15289        /* output mixer control */
15290	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15291	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15292	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15293	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15294	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15295
15296	/* Input mixer control */
15297	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15298	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15299	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15300	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15301	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15302	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15303	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15304	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15305	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15306	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15307
15308	{
15309		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15310		.name = "Channel Mode",
15311		.info = alc_ch_mode_info,
15312		.get = alc_ch_mode_get,
15313		.put = alc_ch_mode_put,
15314                .private_value = ARRAY_SIZE(alc861_asus_modes),
15315	},
15316	{ }
15317};
15318
15319/* additional mixer */
15320static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15321	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15322	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15323	{ }
15324};
15325
15326/*
15327 * generic initialization of ADC, input mixers and output mixers
15328 */
15329static struct hda_verb alc861_base_init_verbs[] = {
15330	/*
15331	 * Unmute ADC0 and set the default input to mic-in
15332	 */
15333	/* port-A for surround (rear panel) */
15334	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15335	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15336	/* port-B for mic-in (rear panel) with vref */
15337	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15338	/* port-C for line-in (rear panel) */
15339	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15340	/* port-D for Front */
15341	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15342	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15343	/* port-E for HP out (front panel) */
15344	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15345	/* route front PCM to HP */
15346	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15347	/* port-F for mic-in (front panel) with vref */
15348	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15349	/* port-G for CLFE (rear panel) */
15350	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15351	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15352	/* port-H for side (rear panel) */
15353	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15354	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15355	/* CD-in */
15356	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15357	/* route front mic to ADC1*/
15358	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15359	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15360
15361	/* Unmute DAC0~3 & spdif out*/
15362	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15363	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15364	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15365	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15366	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15367
15368	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15369	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15370        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15371	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15372        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15373
15374	/* Unmute Stereo Mixer 15 */
15375	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15376	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15377	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15378	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15379
15380	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15381	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15382	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15383	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15384	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15385	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15386	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15387	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15388	/* hp used DAC 3 (Front) */
15389	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15390        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15391
15392	{ }
15393};
15394
15395static struct hda_verb alc861_threestack_init_verbs[] = {
15396	/*
15397	 * Unmute ADC0 and set the default input to mic-in
15398	 */
15399	/* port-A for surround (rear panel) */
15400	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15401	/* port-B for mic-in (rear panel) with vref */
15402	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15403	/* port-C for line-in (rear panel) */
15404	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15405	/* port-D for Front */
15406	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15407	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15408	/* port-E for HP out (front panel) */
15409	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15410	/* route front PCM to HP */
15411	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15412	/* port-F for mic-in (front panel) with vref */
15413	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15414	/* port-G for CLFE (rear panel) */
15415	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15416	/* port-H for side (rear panel) */
15417	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15418	/* CD-in */
15419	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15420	/* route front mic to ADC1*/
15421	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15422	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15423	/* Unmute DAC0~3 & spdif out*/
15424	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15425	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15426	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15427	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15428	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15429
15430	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15431	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15432        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15433	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15434        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15435
15436	/* Unmute Stereo Mixer 15 */
15437	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15438	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15439	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15440	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15441
15442	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15443	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15444	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15445	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15446	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15447	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15448	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15449	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15450	/* hp used DAC 3 (Front) */
15451	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15452        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15453	{ }
15454};
15455
15456static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15457	/*
15458	 * Unmute ADC0 and set the default input to mic-in
15459	 */
15460	/* port-A for surround (rear panel) */
15461	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15462	/* port-B for mic-in (rear panel) with vref */
15463	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15464	/* port-C for line-in (rear panel) */
15465	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15466	/* port-D for Front */
15467	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15468	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15469	/* port-E for HP out (front panel) */
15470	/* this has to be set to VREF80 */
15471	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15472	/* route front PCM to HP */
15473	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15474	/* port-F for mic-in (front panel) with vref */
15475	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15476	/* port-G for CLFE (rear panel) */
15477	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15478	/* port-H for side (rear panel) */
15479	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15480	/* CD-in */
15481	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15482	/* route front mic to ADC1*/
15483	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15484	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15485	/* Unmute DAC0~3 & spdif out*/
15486	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15487	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15488	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15489	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15490	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15491
15492	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15493	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15494        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15495	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15496        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15497
15498	/* Unmute Stereo Mixer 15 */
15499	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15500	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15501	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15502	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15503
15504	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15505	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15506	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15507	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15508	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15509	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15510	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15511	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15512	/* hp used DAC 3 (Front) */
15513	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15514        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15515	{ }
15516};
15517
15518static struct hda_verb alc861_asus_init_verbs[] = {
15519	/*
15520	 * Unmute ADC0 and set the default input to mic-in
15521	 */
15522	/* port-A for surround (rear panel)
15523	 * according to codec#0 this is the HP jack
15524	 */
15525	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15526	/* route front PCM to HP */
15527	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15528	/* port-B for mic-in (rear panel) with vref */
15529	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15530	/* port-C for line-in (rear panel) */
15531	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15532	/* port-D for Front */
15533	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15534	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15535	/* port-E for HP out (front panel) */
15536	/* this has to be set to VREF80 */
15537	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15538	/* route front PCM to HP */
15539	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15540	/* port-F for mic-in (front panel) with vref */
15541	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15542	/* port-G for CLFE (rear panel) */
15543	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15544	/* port-H for side (rear panel) */
15545	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15546	/* CD-in */
15547	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15548	/* route front mic to ADC1*/
15549	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15550	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15551	/* Unmute DAC0~3 & spdif out*/
15552	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15553	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15554	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15555	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15556	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15557	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15558	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15559        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15560	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15561        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15562
15563	/* Unmute Stereo Mixer 15 */
15564	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15565	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15566	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15567	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15568
15569	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15570	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15571	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15572	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15573	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15574	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15575	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15576	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15577	/* hp used DAC 3 (Front) */
15578	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15579	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15580	{ }
15581};
15582
15583/* additional init verbs for ASUS laptops */
15584static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15585	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15586	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15587	{ }
15588};
15589
15590/*
15591 * generic initialization of ADC, input mixers and output mixers
15592 */
15593static struct hda_verb alc861_auto_init_verbs[] = {
15594	/*
15595	 * Unmute ADC0 and set the default input to mic-in
15596	 */
15597	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15598	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15599
15600	/* Unmute DAC0~3 & spdif out*/
15601	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15602	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15603	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15604	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15605	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15606
15607	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15608	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15609	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15610	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15611	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15612
15613	/* Unmute Stereo Mixer 15 */
15614	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15615	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15616	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15617	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15618
15619	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15620	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15621	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15622	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15623	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15624	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15625	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15626	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15627
15628	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15629	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15630	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15631	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15632	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15633	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15634	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15635	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15636
15637	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
15638
15639	{ }
15640};
15641
15642static struct hda_verb alc861_toshiba_init_verbs[] = {
15643	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15644
15645	{ }
15646};
15647
15648/* toggle speaker-output according to the hp-jack state */
15649static void alc861_toshiba_automute(struct hda_codec *codec)
15650{
15651	unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15652
15653	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15654				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15655	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15656				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15657}
15658
15659static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15660				       unsigned int res)
15661{
15662	if ((res >> 26) == ALC880_HP_EVENT)
15663		alc861_toshiba_automute(codec);
15664}
15665
15666/* pcm configuration: identical with ALC880 */
15667#define alc861_pcm_analog_playback	alc880_pcm_analog_playback
15668#define alc861_pcm_analog_capture	alc880_pcm_analog_capture
15669#define alc861_pcm_digital_playback	alc880_pcm_digital_playback
15670#define alc861_pcm_digital_capture	alc880_pcm_digital_capture
15671
15672
15673#define ALC861_DIGOUT_NID	0x07
15674
15675static struct hda_channel_mode alc861_8ch_modes[1] = {
15676	{ 8, NULL }
15677};
15678
15679static hda_nid_t alc861_dac_nids[4] = {
15680	/* front, surround, clfe, side */
15681	0x03, 0x06, 0x05, 0x04
15682};
15683
15684static hda_nid_t alc660_dac_nids[3] = {
15685	/* front, clfe, surround */
15686	0x03, 0x05, 0x06
15687};
15688
15689static hda_nid_t alc861_adc_nids[1] = {
15690	/* ADC0-2 */
15691	0x08,
15692};
15693
15694static struct hda_input_mux alc861_capture_source = {
15695	.num_items = 5,
15696	.items = {
15697		{ "Mic", 0x0 },
15698		{ "Front Mic", 0x3 },
15699		{ "Line", 0x1 },
15700		{ "CD", 0x4 },
15701		{ "Mixer", 0x5 },
15702	},
15703};
15704
15705static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15706{
15707	struct alc_spec *spec = codec->spec;
15708	hda_nid_t mix, srcs[5];
15709	int i, j, num;
15710
15711	if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15712		return 0;
15713	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15714	if (num < 0)
15715		return 0;
15716	for (i = 0; i < num; i++) {
15717		unsigned int type;
15718		type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15719		if (type != AC_WID_AUD_OUT)
15720			continue;
15721		for (j = 0; j < spec->multiout.num_dacs; j++)
15722			if (spec->multiout.dac_nids[j] == srcs[i])
15723				break;
15724		if (j >= spec->multiout.num_dacs)
15725			return srcs[i];
15726	}
15727	return 0;
15728}
15729
15730/* fill in the dac_nids table from the parsed pin configuration */
15731static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15732				     const struct auto_pin_cfg *cfg)
15733{
15734	struct alc_spec *spec = codec->spec;
15735	int i;
15736	hda_nid_t nid, dac;
15737
15738	spec->multiout.dac_nids = spec->private_dac_nids;
15739	for (i = 0; i < cfg->line_outs; i++) {
15740		nid = cfg->line_out_pins[i];
15741		dac = alc861_look_for_dac(codec, nid);
15742		if (!dac)
15743			continue;
15744		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15745	}
15746	return 0;
15747}
15748
15749static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15750				hda_nid_t nid, unsigned int chs)
15751{
15752	return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
15753			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15754}
15755
15756/* add playback controls from the parsed DAC table */
15757static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15758					     const struct auto_pin_cfg *cfg)
15759{
15760	struct alc_spec *spec = codec->spec;
15761	static const char *chname[4] = {
15762		"Front", "Surround", NULL /*CLFE*/, "Side"
15763	};
15764	hda_nid_t nid;
15765	int i, err;
15766
15767	if (cfg->line_outs == 1) {
15768		const char *pfx = NULL;
15769		if (!cfg->hp_outs)
15770			pfx = "Master";
15771		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15772			pfx = "Speaker";
15773		if (pfx) {
15774			nid = spec->multiout.dac_nids[0];
15775			return alc861_create_out_sw(codec, pfx, nid, 3);
15776		}
15777	}
15778
15779	for (i = 0; i < cfg->line_outs; i++) {
15780		nid = spec->multiout.dac_nids[i];
15781		if (!nid)
15782			continue;
15783		if (i == 2) {
15784			/* Center/LFE */
15785			err = alc861_create_out_sw(codec, "Center", nid, 1);
15786			if (err < 0)
15787				return err;
15788			err = alc861_create_out_sw(codec, "LFE", nid, 2);
15789			if (err < 0)
15790				return err;
15791		} else {
15792			err = alc861_create_out_sw(codec, chname[i], nid, 3);
15793			if (err < 0)
15794				return err;
15795		}
15796	}
15797	return 0;
15798}
15799
15800static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15801{
15802	struct alc_spec *spec = codec->spec;
15803	int err;
15804	hda_nid_t nid;
15805
15806	if (!pin)
15807		return 0;
15808
15809	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15810		nid = alc861_look_for_dac(codec, pin);
15811		if (nid) {
15812			err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15813			if (err < 0)
15814				return err;
15815			spec->multiout.hp_nid = nid;
15816		}
15817	}
15818	return 0;
15819}
15820
15821/* create playback/capture controls for input pins */
15822static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15823						const struct auto_pin_cfg *cfg)
15824{
15825	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15826}
15827
15828static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15829					      hda_nid_t nid,
15830					      int pin_type, hda_nid_t dac)
15831{
15832	hda_nid_t mix, srcs[5];
15833	int i, num;
15834
15835	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15836			    pin_type);
15837	snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15838			    AMP_OUT_UNMUTE);
15839	if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15840		return;
15841	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15842	if (num < 0)
15843		return;
15844	for (i = 0; i < num; i++) {
15845		unsigned int mute;
15846		if (srcs[i] == dac || srcs[i] == 0x15)
15847			mute = AMP_IN_UNMUTE(i);
15848		else
15849			mute = AMP_IN_MUTE(i);
15850		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15851				    mute);
15852	}
15853}
15854
15855static void alc861_auto_init_multi_out(struct hda_codec *codec)
15856{
15857	struct alc_spec *spec = codec->spec;
15858	int i;
15859
15860	for (i = 0; i < spec->autocfg.line_outs; i++) {
15861		hda_nid_t nid = spec->autocfg.line_out_pins[i];
15862		int pin_type = get_pin_type(spec->autocfg.line_out_type);
15863		if (nid)
15864			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15865							  spec->multiout.dac_nids[i]);
15866	}
15867}
15868
15869static void alc861_auto_init_hp_out(struct hda_codec *codec)
15870{
15871	struct alc_spec *spec = codec->spec;
15872
15873	if (spec->autocfg.hp_outs)
15874		alc861_auto_set_output_and_unmute(codec,
15875						  spec->autocfg.hp_pins[0],
15876						  PIN_HP,
15877						  spec->multiout.hp_nid);
15878	if (spec->autocfg.speaker_outs)
15879		alc861_auto_set_output_and_unmute(codec,
15880						  spec->autocfg.speaker_pins[0],
15881						  PIN_OUT,
15882						  spec->multiout.dac_nids[0]);
15883}
15884
15885static void alc861_auto_init_analog_input(struct hda_codec *codec)
15886{
15887	struct alc_spec *spec = codec->spec;
15888	struct auto_pin_cfg *cfg = &spec->autocfg;
15889	int i;
15890
15891	for (i = 0; i < cfg->num_inputs; i++) {
15892		hda_nid_t nid = cfg->inputs[i].pin;
15893		if (nid >= 0x0c && nid <= 0x11)
15894			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
15895	}
15896}
15897
15898/* parse the BIOS configuration and set up the alc_spec */
15899/* return 1 if successful, 0 if the proper config is not found,
15900 * or a negative error code
15901 */
15902static int alc861_parse_auto_config(struct hda_codec *codec)
15903{
15904	struct alc_spec *spec = codec->spec;
15905	int err;
15906	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15907
15908	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15909					   alc861_ignore);
15910	if (err < 0)
15911		return err;
15912	if (!spec->autocfg.line_outs)
15913		return 0; /* can't find valid BIOS pin config */
15914
15915	err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15916	if (err < 0)
15917		return err;
15918	err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15919	if (err < 0)
15920		return err;
15921	err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15922	if (err < 0)
15923		return err;
15924	err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15925	if (err < 0)
15926		return err;
15927
15928	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15929
15930	alc_auto_parse_digital(codec);
15931
15932	if (spec->kctls.list)
15933		add_mixer(spec, spec->kctls.list);
15934
15935	add_verb(spec, alc861_auto_init_verbs);
15936
15937	spec->num_mux_defs = 1;
15938	spec->input_mux = &spec->private_imux[0];
15939
15940	spec->adc_nids = alc861_adc_nids;
15941	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15942	set_capture_mixer(codec);
15943
15944	alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15945
15946	return 1;
15947}
15948
15949/* additional initialization for auto-configuration model */
15950static void alc861_auto_init(struct hda_codec *codec)
15951{
15952	struct alc_spec *spec = codec->spec;
15953	alc861_auto_init_multi_out(codec);
15954	alc861_auto_init_hp_out(codec);
15955	alc861_auto_init_analog_input(codec);
15956	alc_auto_init_digital(codec);
15957	if (spec->unsol_event)
15958		alc_inithook(codec);
15959}
15960
15961#ifdef CONFIG_SND_HDA_POWER_SAVE
15962static struct hda_amp_list alc861_loopbacks[] = {
15963	{ 0x15, HDA_INPUT, 0 },
15964	{ 0x15, HDA_INPUT, 1 },
15965	{ 0x15, HDA_INPUT, 2 },
15966	{ 0x15, HDA_INPUT, 3 },
15967	{ } /* end */
15968};
15969#endif
15970
15971
15972/*
15973 * configuration and preset
15974 */
15975static const char *alc861_models[ALC861_MODEL_LAST] = {
15976	[ALC861_3ST]		= "3stack",
15977	[ALC660_3ST]		= "3stack-660",
15978	[ALC861_3ST_DIG]	= "3stack-dig",
15979	[ALC861_6ST_DIG]	= "6stack-dig",
15980	[ALC861_UNIWILL_M31]	= "uniwill-m31",
15981	[ALC861_TOSHIBA]	= "toshiba",
15982	[ALC861_ASUS]		= "asus",
15983	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
15984	[ALC861_AUTO]		= "auto",
15985};
15986
15987static struct snd_pci_quirk alc861_cfg_tbl[] = {
15988	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15989	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15990	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15991	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15992	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15993	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
15994	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
15995	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
15996	 *        Any other models that need this preset?
15997	 */
15998	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
15999	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16000	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16001	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16002	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16003	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16004	/* FIXME: the below seems conflict */
16005	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16006	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16007	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16008	{}
16009};
16010
16011static struct alc_config_preset alc861_presets[] = {
16012	[ALC861_3ST] = {
16013		.mixers = { alc861_3ST_mixer },
16014		.init_verbs = { alc861_threestack_init_verbs },
16015		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16016		.dac_nids = alc861_dac_nids,
16017		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16018		.channel_mode = alc861_threestack_modes,
16019		.need_dac_fix = 1,
16020		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16021		.adc_nids = alc861_adc_nids,
16022		.input_mux = &alc861_capture_source,
16023	},
16024	[ALC861_3ST_DIG] = {
16025		.mixers = { alc861_base_mixer },
16026		.init_verbs = { alc861_threestack_init_verbs },
16027		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16028		.dac_nids = alc861_dac_nids,
16029		.dig_out_nid = ALC861_DIGOUT_NID,
16030		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16031		.channel_mode = alc861_threestack_modes,
16032		.need_dac_fix = 1,
16033		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16034		.adc_nids = alc861_adc_nids,
16035		.input_mux = &alc861_capture_source,
16036	},
16037	[ALC861_6ST_DIG] = {
16038		.mixers = { alc861_base_mixer },
16039		.init_verbs = { alc861_base_init_verbs },
16040		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16041		.dac_nids = alc861_dac_nids,
16042		.dig_out_nid = ALC861_DIGOUT_NID,
16043		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16044		.channel_mode = alc861_8ch_modes,
16045		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16046		.adc_nids = alc861_adc_nids,
16047		.input_mux = &alc861_capture_source,
16048	},
16049	[ALC660_3ST] = {
16050		.mixers = { alc861_3ST_mixer },
16051		.init_verbs = { alc861_threestack_init_verbs },
16052		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
16053		.dac_nids = alc660_dac_nids,
16054		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16055		.channel_mode = alc861_threestack_modes,
16056		.need_dac_fix = 1,
16057		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16058		.adc_nids = alc861_adc_nids,
16059		.input_mux = &alc861_capture_source,
16060	},
16061	[ALC861_UNIWILL_M31] = {
16062		.mixers = { alc861_uniwill_m31_mixer },
16063		.init_verbs = { alc861_uniwill_m31_init_verbs },
16064		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16065		.dac_nids = alc861_dac_nids,
16066		.dig_out_nid = ALC861_DIGOUT_NID,
16067		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16068		.channel_mode = alc861_uniwill_m31_modes,
16069		.need_dac_fix = 1,
16070		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16071		.adc_nids = alc861_adc_nids,
16072		.input_mux = &alc861_capture_source,
16073	},
16074	[ALC861_TOSHIBA] = {
16075		.mixers = { alc861_toshiba_mixer },
16076		.init_verbs = { alc861_base_init_verbs,
16077				alc861_toshiba_init_verbs },
16078		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16079		.dac_nids = alc861_dac_nids,
16080		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16081		.channel_mode = alc883_3ST_2ch_modes,
16082		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16083		.adc_nids = alc861_adc_nids,
16084		.input_mux = &alc861_capture_source,
16085		.unsol_event = alc861_toshiba_unsol_event,
16086		.init_hook = alc861_toshiba_automute,
16087	},
16088	[ALC861_ASUS] = {
16089		.mixers = { alc861_asus_mixer },
16090		.init_verbs = { alc861_asus_init_verbs },
16091		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16092		.dac_nids = alc861_dac_nids,
16093		.dig_out_nid = ALC861_DIGOUT_NID,
16094		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16095		.channel_mode = alc861_asus_modes,
16096		.need_dac_fix = 1,
16097		.hp_nid = 0x06,
16098		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16099		.adc_nids = alc861_adc_nids,
16100		.input_mux = &alc861_capture_source,
16101	},
16102	[ALC861_ASUS_LAPTOP] = {
16103		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16104		.init_verbs = { alc861_asus_init_verbs,
16105				alc861_asus_laptop_init_verbs },
16106		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16107		.dac_nids = alc861_dac_nids,
16108		.dig_out_nid = ALC861_DIGOUT_NID,
16109		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16110		.channel_mode = alc883_3ST_2ch_modes,
16111		.need_dac_fix = 1,
16112		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16113		.adc_nids = alc861_adc_nids,
16114		.input_mux = &alc861_capture_source,
16115	},
16116};
16117
16118/* Pin config fixes */
16119enum {
16120	PINFIX_FSC_AMILO_PI1505,
16121};
16122
16123static const struct alc_fixup alc861_fixups[] = {
16124	[PINFIX_FSC_AMILO_PI1505] = {
16125		.pins = (const struct alc_pincfg[]) {
16126			{ 0x0b, 0x0221101f }, /* HP */
16127			{ 0x0f, 0x90170310 }, /* speaker */
16128			{ }
16129		}
16130	},
16131};
16132
16133static struct snd_pci_quirk alc861_fixup_tbl[] = {
16134	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16135	{}
16136};
16137
16138static int patch_alc861(struct hda_codec *codec)
16139{
16140	struct alc_spec *spec;
16141	int board_config;
16142	int err;
16143
16144	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16145	if (spec == NULL)
16146		return -ENOMEM;
16147
16148	codec->spec = spec;
16149
16150        board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16151						  alc861_models,
16152						  alc861_cfg_tbl);
16153
16154	if (board_config < 0) {
16155		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16156		       codec->chip_name);
16157		board_config = ALC861_AUTO;
16158	}
16159
16160	if (board_config == ALC861_AUTO)
16161		alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
16162
16163	if (board_config == ALC861_AUTO) {
16164		/* automatic parse from the BIOS config */
16165		err = alc861_parse_auto_config(codec);
16166		if (err < 0) {
16167			alc_free(codec);
16168			return err;
16169		} else if (!err) {
16170			printk(KERN_INFO
16171			       "hda_codec: Cannot set up configuration "
16172			       "from BIOS.  Using base mode...\n");
16173		   board_config = ALC861_3ST_DIG;
16174		}
16175	}
16176
16177	err = snd_hda_attach_beep_device(codec, 0x23);
16178	if (err < 0) {
16179		alc_free(codec);
16180		return err;
16181	}
16182
16183	if (board_config != ALC861_AUTO)
16184		setup_preset(codec, &alc861_presets[board_config]);
16185
16186	spec->stream_analog_playback = &alc861_pcm_analog_playback;
16187	spec->stream_analog_capture = &alc861_pcm_analog_capture;
16188
16189	spec->stream_digital_playback = &alc861_pcm_digital_playback;
16190	spec->stream_digital_capture = &alc861_pcm_digital_capture;
16191
16192	if (!spec->cap_mixer)
16193		set_capture_mixer(codec);
16194	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16195
16196	spec->vmaster_nid = 0x03;
16197
16198	if (board_config == ALC861_AUTO)
16199		alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
16200
16201	codec->patch_ops = alc_patch_ops;
16202	if (board_config == ALC861_AUTO) {
16203		spec->init_hook = alc861_auto_init;
16204#ifdef CONFIG_SND_HDA_POWER_SAVE
16205		spec->power_hook = alc_power_eapd;
16206#endif
16207	}
16208#ifdef CONFIG_SND_HDA_POWER_SAVE
16209	if (!spec->loopback.amplist)
16210		spec->loopback.amplist = alc861_loopbacks;
16211#endif
16212
16213	return 0;
16214}
16215
16216/*
16217 * ALC861-VD support
16218 *
16219 * Based on ALC882
16220 *
16221 * In addition, an independent DAC
16222 */
16223#define ALC861VD_DIGOUT_NID	0x06
16224
16225static hda_nid_t alc861vd_dac_nids[4] = {
16226	/* front, surr, clfe, side surr */
16227	0x02, 0x03, 0x04, 0x05
16228};
16229
16230/* dac_nids for ALC660vd are in a different order - according to
16231 * Realtek's driver.
16232 * This should probably result in a different mixer for 6stack models
16233 * of ALC660vd codecs, but for now there is only 3stack mixer
16234 * - and it is the same as in 861vd.
16235 * adc_nids in ALC660vd are (is) the same as in 861vd
16236 */
16237static hda_nid_t alc660vd_dac_nids[3] = {
16238	/* front, rear, clfe, rear_surr */
16239	0x02, 0x04, 0x03
16240};
16241
16242static hda_nid_t alc861vd_adc_nids[1] = {
16243	/* ADC0 */
16244	0x09,
16245};
16246
16247static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16248
16249/* input MUX */
16250/* FIXME: should be a matrix-type input source selection */
16251static struct hda_input_mux alc861vd_capture_source = {
16252	.num_items = 4,
16253	.items = {
16254		{ "Mic", 0x0 },
16255		{ "Front Mic", 0x1 },
16256		{ "Line", 0x2 },
16257		{ "CD", 0x4 },
16258	},
16259};
16260
16261static struct hda_input_mux alc861vd_dallas_capture_source = {
16262	.num_items = 2,
16263	.items = {
16264		{ "Ext Mic", 0x0 },
16265		{ "Int Mic", 0x1 },
16266	},
16267};
16268
16269static struct hda_input_mux alc861vd_hp_capture_source = {
16270	.num_items = 2,
16271	.items = {
16272		{ "Front Mic", 0x0 },
16273		{ "ATAPI Mic", 0x1 },
16274	},
16275};
16276
16277/*
16278 * 2ch mode
16279 */
16280static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16281	{ 2, NULL }
16282};
16283
16284/*
16285 * 6ch mode
16286 */
16287static struct hda_verb alc861vd_6stack_ch6_init[] = {
16288	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16289	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16290	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16291	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16292	{ } /* end */
16293};
16294
16295/*
16296 * 8ch mode
16297 */
16298static struct hda_verb alc861vd_6stack_ch8_init[] = {
16299	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16300	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16301	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16302	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16303	{ } /* end */
16304};
16305
16306static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16307	{ 6, alc861vd_6stack_ch6_init },
16308	{ 8, alc861vd_6stack_ch8_init },
16309};
16310
16311static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16312	{
16313		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16314		.name = "Channel Mode",
16315		.info = alc_ch_mode_info,
16316		.get = alc_ch_mode_get,
16317		.put = alc_ch_mode_put,
16318	},
16319	{ } /* end */
16320};
16321
16322/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16323 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16324 */
16325static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16326	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16327	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16328
16329	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16330	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16331
16332	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16333				HDA_OUTPUT),
16334	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16335				HDA_OUTPUT),
16336	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16337	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16338
16339	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16340	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16341
16342	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16343
16344	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16345	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16346	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16347
16348	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16349	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16350	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16351
16352	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16353	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16354
16355	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16356	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16357
16358	{ } /* end */
16359};
16360
16361static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16362	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16363	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16364
16365	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16366
16367	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16368	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16369	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16370
16371	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16372	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16373	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16374
16375	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16376	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16377
16378	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16379	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16380
16381	{ } /* end */
16382};
16383
16384static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16385	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16386	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16387	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16388
16389	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16390
16391	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16392	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16393	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16394
16395	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16396	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16397	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16398
16399	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16400	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16401
16402	{ } /* end */
16403};
16404
16405/* Pin assignment: Speaker=0x14, HP = 0x15,
16406 *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16407 */
16408static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16409	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16410	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16411	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16412	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16413	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16414	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16415	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16416	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16417	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16418	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16419	{ } /* end */
16420};
16421
16422/* Pin assignment: Speaker=0x14, Line-out = 0x15,
16423 *                 Front Mic=0x18, ATAPI Mic = 0x19,
16424 */
16425static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16426	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16427	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16428	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16429	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16430	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16431	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16432	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16433	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16434
16435	{ } /* end */
16436};
16437
16438/*
16439 * generic initialization of ADC, input mixers and output mixers
16440 */
16441static struct hda_verb alc861vd_volume_init_verbs[] = {
16442	/*
16443	 * Unmute ADC0 and set the default input to mic-in
16444	 */
16445	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16446	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16447
16448	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16449	 * the analog-loopback mixer widget
16450	 */
16451	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16452	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16453	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16454	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16455	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16456	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16457
16458	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16459	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16460	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16461	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16462	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16463
16464	/*
16465	 * Set up output mixers (0x02 - 0x05)
16466	 */
16467	/* set vol=0 to output mixers */
16468	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16469	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16470	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16471	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16472
16473	/* set up input amps for analog loopback */
16474	/* Amp Indices: DAC = 0, mixer = 1 */
16475	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16476	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16477	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16478	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16479	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16480	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16481	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16482	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16483
16484	{ }
16485};
16486
16487/*
16488 * 3-stack pin configuration:
16489 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16490 */
16491static struct hda_verb alc861vd_3stack_init_verbs[] = {
16492	/*
16493	 * Set pin mode and muting
16494	 */
16495	/* set front pin widgets 0x14 for output */
16496	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16497	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16498	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16499
16500	/* Mic (rear) pin: input vref at 80% */
16501	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16502	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16503	/* Front Mic pin: input vref at 80% */
16504	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16505	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16506	/* Line In pin: input */
16507	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16508	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16509	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16510	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16511	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16512	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16513	/* CD pin widget for input */
16514	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16515
16516	{ }
16517};
16518
16519/*
16520 * 6-stack pin configuration:
16521 */
16522static struct hda_verb alc861vd_6stack_init_verbs[] = {
16523	/*
16524	 * Set pin mode and muting
16525	 */
16526	/* set front pin widgets 0x14 for output */
16527	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16528	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16529	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16530
16531	/* Rear Pin: output 1 (0x0d) */
16532	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16533	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16534	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16535	/* CLFE Pin: output 2 (0x0e) */
16536	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16537	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16538	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16539	/* Side Pin: output 3 (0x0f) */
16540	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16541	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16542	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16543
16544	/* Mic (rear) pin: input vref at 80% */
16545	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16546	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16547	/* Front Mic pin: input vref at 80% */
16548	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16549	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16550	/* Line In pin: input */
16551	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16552	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16553	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16554	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16555	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16556	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16557	/* CD pin widget for input */
16558	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16559
16560	{ }
16561};
16562
16563static struct hda_verb alc861vd_eapd_verbs[] = {
16564	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16565	{ }
16566};
16567
16568static struct hda_verb alc660vd_eapd_verbs[] = {
16569	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16570	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16571	{ }
16572};
16573
16574static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16575	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16576	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16577	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16578	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16579	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16580	{}
16581};
16582
16583static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
16584{
16585	unsigned int present;
16586	unsigned char bits;
16587
16588	present = snd_hda_jack_detect(codec, 0x18);
16589	bits = present ? HDA_AMP_MUTE : 0;
16590
16591	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
16592				 HDA_AMP_MUTE, bits);
16593}
16594
16595static void alc861vd_lenovo_setup(struct hda_codec *codec)
16596{
16597	struct alc_spec *spec = codec->spec;
16598	spec->autocfg.hp_pins[0] = 0x1b;
16599	spec->autocfg.speaker_pins[0] = 0x14;
16600}
16601
16602static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16603{
16604	alc_automute_amp(codec);
16605	alc861vd_lenovo_mic_automute(codec);
16606}
16607
16608static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16609					unsigned int res)
16610{
16611	switch (res >> 26) {
16612	case ALC880_MIC_EVENT:
16613		alc861vd_lenovo_mic_automute(codec);
16614		break;
16615	default:
16616		alc_automute_amp_unsol_event(codec, res);
16617		break;
16618	}
16619}
16620
16621static struct hda_verb alc861vd_dallas_verbs[] = {
16622	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16623	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16624	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16625	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16626
16627	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16628	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16629	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16630	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16631	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16632	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16633	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16634	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16635
16636	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16637	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16638	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16639	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16640	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16641	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16642	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16643	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16644
16645	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16646	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16647	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16648	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16649	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16650	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16651	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16652	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16653
16654	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16655	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16656	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16657	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16658
16659	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16660	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16661	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16662
16663	{ } /* end */
16664};
16665
16666/* toggle speaker-output according to the hp-jack state */
16667static void alc861vd_dallas_setup(struct hda_codec *codec)
16668{
16669	struct alc_spec *spec = codec->spec;
16670
16671	spec->autocfg.hp_pins[0] = 0x15;
16672	spec->autocfg.speaker_pins[0] = 0x14;
16673}
16674
16675#ifdef CONFIG_SND_HDA_POWER_SAVE
16676#define alc861vd_loopbacks	alc880_loopbacks
16677#endif
16678
16679/* pcm configuration: identical with ALC880 */
16680#define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
16681#define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
16682#define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
16683#define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
16684
16685/*
16686 * configuration and preset
16687 */
16688static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16689	[ALC660VD_3ST]		= "3stack-660",
16690	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
16691	[ALC660VD_ASUS_V1S]	= "asus-v1s",
16692	[ALC861VD_3ST]		= "3stack",
16693	[ALC861VD_3ST_DIG]	= "3stack-digout",
16694	[ALC861VD_6ST_DIG]	= "6stack-digout",
16695	[ALC861VD_LENOVO]	= "lenovo",
16696	[ALC861VD_DALLAS]	= "dallas",
16697	[ALC861VD_HP]		= "hp",
16698	[ALC861VD_AUTO]		= "auto",
16699};
16700
16701static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16702	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16703	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16704	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16705	/*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16706	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16707	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16708	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16709	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16710	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16711	SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16712	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16713	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16714	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16715	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16716	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16717	{}
16718};
16719
16720static struct alc_config_preset alc861vd_presets[] = {
16721	[ALC660VD_3ST] = {
16722		.mixers = { alc861vd_3st_mixer },
16723		.init_verbs = { alc861vd_volume_init_verbs,
16724				 alc861vd_3stack_init_verbs },
16725		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16726		.dac_nids = alc660vd_dac_nids,
16727		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16728		.channel_mode = alc861vd_3stack_2ch_modes,
16729		.input_mux = &alc861vd_capture_source,
16730	},
16731	[ALC660VD_3ST_DIG] = {
16732		.mixers = { alc861vd_3st_mixer },
16733		.init_verbs = { alc861vd_volume_init_verbs,
16734				 alc861vd_3stack_init_verbs },
16735		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16736		.dac_nids = alc660vd_dac_nids,
16737		.dig_out_nid = ALC861VD_DIGOUT_NID,
16738		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16739		.channel_mode = alc861vd_3stack_2ch_modes,
16740		.input_mux = &alc861vd_capture_source,
16741	},
16742	[ALC861VD_3ST] = {
16743		.mixers = { alc861vd_3st_mixer },
16744		.init_verbs = { alc861vd_volume_init_verbs,
16745				 alc861vd_3stack_init_verbs },
16746		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16747		.dac_nids = alc861vd_dac_nids,
16748		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16749		.channel_mode = alc861vd_3stack_2ch_modes,
16750		.input_mux = &alc861vd_capture_source,
16751	},
16752	[ALC861VD_3ST_DIG] = {
16753		.mixers = { alc861vd_3st_mixer },
16754		.init_verbs = { alc861vd_volume_init_verbs,
16755		 		 alc861vd_3stack_init_verbs },
16756		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16757		.dac_nids = alc861vd_dac_nids,
16758		.dig_out_nid = ALC861VD_DIGOUT_NID,
16759		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16760		.channel_mode = alc861vd_3stack_2ch_modes,
16761		.input_mux = &alc861vd_capture_source,
16762	},
16763	[ALC861VD_6ST_DIG] = {
16764		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16765		.init_verbs = { alc861vd_volume_init_verbs,
16766				alc861vd_6stack_init_verbs },
16767		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16768		.dac_nids = alc861vd_dac_nids,
16769		.dig_out_nid = ALC861VD_DIGOUT_NID,
16770		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16771		.channel_mode = alc861vd_6stack_modes,
16772		.input_mux = &alc861vd_capture_source,
16773	},
16774	[ALC861VD_LENOVO] = {
16775		.mixers = { alc861vd_lenovo_mixer },
16776		.init_verbs = { alc861vd_volume_init_verbs,
16777				alc861vd_3stack_init_verbs,
16778				alc861vd_eapd_verbs,
16779				alc861vd_lenovo_unsol_verbs },
16780		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16781		.dac_nids = alc660vd_dac_nids,
16782		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16783		.channel_mode = alc861vd_3stack_2ch_modes,
16784		.input_mux = &alc861vd_capture_source,
16785		.unsol_event = alc861vd_lenovo_unsol_event,
16786		.setup = alc861vd_lenovo_setup,
16787		.init_hook = alc861vd_lenovo_init_hook,
16788	},
16789	[ALC861VD_DALLAS] = {
16790		.mixers = { alc861vd_dallas_mixer },
16791		.init_verbs = { alc861vd_dallas_verbs },
16792		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16793		.dac_nids = alc861vd_dac_nids,
16794		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16795		.channel_mode = alc861vd_3stack_2ch_modes,
16796		.input_mux = &alc861vd_dallas_capture_source,
16797		.unsol_event = alc_automute_amp_unsol_event,
16798		.setup = alc861vd_dallas_setup,
16799		.init_hook = alc_automute_amp,
16800	},
16801	[ALC861VD_HP] = {
16802		.mixers = { alc861vd_hp_mixer },
16803		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16804		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16805		.dac_nids = alc861vd_dac_nids,
16806		.dig_out_nid = ALC861VD_DIGOUT_NID,
16807		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16808		.channel_mode = alc861vd_3stack_2ch_modes,
16809		.input_mux = &alc861vd_hp_capture_source,
16810		.unsol_event = alc_automute_amp_unsol_event,
16811		.setup = alc861vd_dallas_setup,
16812		.init_hook = alc_automute_amp,
16813	},
16814	[ALC660VD_ASUS_V1S] = {
16815		.mixers = { alc861vd_lenovo_mixer },
16816		.init_verbs = { alc861vd_volume_init_verbs,
16817				alc861vd_3stack_init_verbs,
16818				alc861vd_eapd_verbs,
16819				alc861vd_lenovo_unsol_verbs },
16820		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16821		.dac_nids = alc660vd_dac_nids,
16822		.dig_out_nid = ALC861VD_DIGOUT_NID,
16823		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16824		.channel_mode = alc861vd_3stack_2ch_modes,
16825		.input_mux = &alc861vd_capture_source,
16826		.unsol_event = alc861vd_lenovo_unsol_event,
16827		.setup = alc861vd_lenovo_setup,
16828		.init_hook = alc861vd_lenovo_init_hook,
16829	},
16830};
16831
16832/*
16833 * BIOS auto configuration
16834 */
16835static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16836						const struct auto_pin_cfg *cfg)
16837{
16838	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16839}
16840
16841
16842static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16843				hda_nid_t nid, int pin_type, int dac_idx)
16844{
16845	alc_set_pin_output(codec, nid, pin_type);
16846}
16847
16848static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16849{
16850	struct alc_spec *spec = codec->spec;
16851	int i;
16852
16853	for (i = 0; i <= HDA_SIDE; i++) {
16854		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16855		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16856		if (nid)
16857			alc861vd_auto_set_output_and_unmute(codec, nid,
16858							    pin_type, i);
16859	}
16860}
16861
16862
16863static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16864{
16865	struct alc_spec *spec = codec->spec;
16866	hda_nid_t pin;
16867
16868	pin = spec->autocfg.hp_pins[0];
16869	if (pin) /* connect to front and use dac 0 */
16870		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16871	pin = spec->autocfg.speaker_pins[0];
16872	if (pin)
16873		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16874}
16875
16876#define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
16877
16878static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16879{
16880	struct alc_spec *spec = codec->spec;
16881	struct auto_pin_cfg *cfg = &spec->autocfg;
16882	int i;
16883
16884	for (i = 0; i < cfg->num_inputs; i++) {
16885		hda_nid_t nid = cfg->inputs[i].pin;
16886		if (alc_is_input_pin(codec, nid)) {
16887			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16888			if (nid != ALC861VD_PIN_CD_NID &&
16889			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16890				snd_hda_codec_write(codec, nid, 0,
16891						AC_VERB_SET_AMP_GAIN_MUTE,
16892						AMP_OUT_MUTE);
16893		}
16894	}
16895}
16896
16897#define alc861vd_auto_init_input_src	alc882_auto_init_input_src
16898
16899#define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
16900#define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
16901
16902/* add playback controls from the parsed DAC table */
16903/* Based on ALC880 version. But ALC861VD has separate,
16904 * different NIDs for mute/unmute switch and volume control */
16905static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16906					     const struct auto_pin_cfg *cfg)
16907{
16908	static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16909	hda_nid_t nid_v, nid_s;
16910	int i, err;
16911
16912	for (i = 0; i < cfg->line_outs; i++) {
16913		if (!spec->multiout.dac_nids[i])
16914			continue;
16915		nid_v = alc861vd_idx_to_mixer_vol(
16916				alc880_dac_to_idx(
16917					spec->multiout.dac_nids[i]));
16918		nid_s = alc861vd_idx_to_mixer_switch(
16919				alc880_dac_to_idx(
16920					spec->multiout.dac_nids[i]));
16921
16922		if (i == 2) {
16923			/* Center/LFE */
16924			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16925					      "Center",
16926					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16927							      HDA_OUTPUT));
16928			if (err < 0)
16929				return err;
16930			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16931					      "LFE",
16932					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16933							      HDA_OUTPUT));
16934			if (err < 0)
16935				return err;
16936			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16937					     "Center",
16938					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16939							      HDA_INPUT));
16940			if (err < 0)
16941				return err;
16942			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16943					     "LFE",
16944					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16945							      HDA_INPUT));
16946			if (err < 0)
16947				return err;
16948		} else {
16949			const char *pfx;
16950			if (cfg->line_outs == 1 &&
16951			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16952				if (!cfg->hp_pins)
16953					pfx = "Speaker";
16954				else
16955					pfx = "PCM";
16956			} else
16957				pfx = chname[i];
16958			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16959					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16960							      HDA_OUTPUT));
16961			if (err < 0)
16962				return err;
16963			if (cfg->line_outs == 1 &&
16964			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16965				pfx = "Speaker";
16966			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16967					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16968							      HDA_INPUT));
16969			if (err < 0)
16970				return err;
16971		}
16972	}
16973	return 0;
16974}
16975
16976/* add playback controls for speaker and HP outputs */
16977/* Based on ALC880 version. But ALC861VD has separate,
16978 * different NIDs for mute/unmute switch and volume control */
16979static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16980					hda_nid_t pin, const char *pfx)
16981{
16982	hda_nid_t nid_v, nid_s;
16983	int err;
16984
16985	if (!pin)
16986		return 0;
16987
16988	if (alc880_is_fixed_pin(pin)) {
16989		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16990		/* specify the DAC as the extra output */
16991		if (!spec->multiout.hp_nid)
16992			spec->multiout.hp_nid = nid_v;
16993		else
16994			spec->multiout.extra_out_nid[0] = nid_v;
16995		/* control HP volume/switch on the output mixer amp */
16996		nid_v = alc861vd_idx_to_mixer_vol(
16997				alc880_fixed_pin_idx(pin));
16998		nid_s = alc861vd_idx_to_mixer_switch(
16999				alc880_fixed_pin_idx(pin));
17000
17001		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17002				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17003		if (err < 0)
17004			return err;
17005		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17006				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17007		if (err < 0)
17008			return err;
17009	} else if (alc880_is_multi_pin(pin)) {
17010		/* set manual connection */
17011		/* we have only a switch on HP-out PIN */
17012		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17013				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17014		if (err < 0)
17015			return err;
17016	}
17017	return 0;
17018}
17019
17020/* parse the BIOS configuration and set up the alc_spec
17021 * return 1 if successful, 0 if the proper config is not found,
17022 * or a negative error code
17023 * Based on ALC880 version - had to change it to override
17024 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17025static int alc861vd_parse_auto_config(struct hda_codec *codec)
17026{
17027	struct alc_spec *spec = codec->spec;
17028	int err;
17029	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17030
17031	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17032					   alc861vd_ignore);
17033	if (err < 0)
17034		return err;
17035	if (!spec->autocfg.line_outs)
17036		return 0; /* can't find valid BIOS pin config */
17037
17038	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17039	if (err < 0)
17040		return err;
17041	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17042	if (err < 0)
17043		return err;
17044	err = alc861vd_auto_create_extra_out(spec,
17045					     spec->autocfg.speaker_pins[0],
17046					     "Speaker");
17047	if (err < 0)
17048		return err;
17049	err = alc861vd_auto_create_extra_out(spec,
17050					     spec->autocfg.hp_pins[0],
17051					     "Headphone");
17052	if (err < 0)
17053		return err;
17054	err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17055	if (err < 0)
17056		return err;
17057
17058	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17059
17060	alc_auto_parse_digital(codec);
17061
17062	if (spec->kctls.list)
17063		add_mixer(spec, spec->kctls.list);
17064
17065	add_verb(spec, alc861vd_volume_init_verbs);
17066
17067	spec->num_mux_defs = 1;
17068	spec->input_mux = &spec->private_imux[0];
17069
17070	err = alc_auto_add_mic_boost(codec);
17071	if (err < 0)
17072		return err;
17073
17074	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17075
17076	return 1;
17077}
17078
17079/* additional initialization for auto-configuration model */
17080static void alc861vd_auto_init(struct hda_codec *codec)
17081{
17082	struct alc_spec *spec = codec->spec;
17083	alc861vd_auto_init_multi_out(codec);
17084	alc861vd_auto_init_hp_out(codec);
17085	alc861vd_auto_init_analog_input(codec);
17086	alc861vd_auto_init_input_src(codec);
17087	alc_auto_init_digital(codec);
17088	if (spec->unsol_event)
17089		alc_inithook(codec);
17090}
17091
17092enum {
17093	ALC660VD_FIX_ASUS_GPIO1
17094};
17095
17096/* reset GPIO1 */
17097static const struct alc_fixup alc861vd_fixups[] = {
17098	[ALC660VD_FIX_ASUS_GPIO1] = {
17099		.verbs = (const struct hda_verb[]) {
17100			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17101			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17102			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17103			{ }
17104		}
17105	},
17106};
17107
17108static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17109	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17110	{}
17111};
17112
17113static int patch_alc861vd(struct hda_codec *codec)
17114{
17115	struct alc_spec *spec;
17116	int err, board_config;
17117
17118	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17119	if (spec == NULL)
17120		return -ENOMEM;
17121
17122	codec->spec = spec;
17123
17124	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17125						  alc861vd_models,
17126						  alc861vd_cfg_tbl);
17127
17128	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17129		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17130		       codec->chip_name);
17131		board_config = ALC861VD_AUTO;
17132	}
17133
17134	if (board_config == ALC861VD_AUTO)
17135		alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
17136
17137	if (board_config == ALC861VD_AUTO) {
17138		/* automatic parse from the BIOS config */
17139		err = alc861vd_parse_auto_config(codec);
17140		if (err < 0) {
17141			alc_free(codec);
17142			return err;
17143		} else if (!err) {
17144			printk(KERN_INFO
17145			       "hda_codec: Cannot set up configuration "
17146			       "from BIOS.  Using base mode...\n");
17147			board_config = ALC861VD_3ST;
17148		}
17149	}
17150
17151	err = snd_hda_attach_beep_device(codec, 0x23);
17152	if (err < 0) {
17153		alc_free(codec);
17154		return err;
17155	}
17156
17157	if (board_config != ALC861VD_AUTO)
17158		setup_preset(codec, &alc861vd_presets[board_config]);
17159
17160	if (codec->vendor_id == 0x10ec0660) {
17161		/* always turn on EAPD */
17162		add_verb(spec, alc660vd_eapd_verbs);
17163	}
17164
17165	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17166	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17167
17168	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17169	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17170
17171	if (!spec->adc_nids) {
17172		spec->adc_nids = alc861vd_adc_nids;
17173		spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17174	}
17175	if (!spec->capsrc_nids)
17176		spec->capsrc_nids = alc861vd_capsrc_nids;
17177
17178	set_capture_mixer(codec);
17179	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17180
17181	spec->vmaster_nid = 0x02;
17182
17183	if (board_config == ALC861VD_AUTO)
17184		alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
17185
17186	codec->patch_ops = alc_patch_ops;
17187
17188	if (board_config == ALC861VD_AUTO)
17189		spec->init_hook = alc861vd_auto_init;
17190#ifdef CONFIG_SND_HDA_POWER_SAVE
17191	if (!spec->loopback.amplist)
17192		spec->loopback.amplist = alc861vd_loopbacks;
17193#endif
17194
17195	return 0;
17196}
17197
17198/*
17199 * ALC662 support
17200 *
17201 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17202 * configuration.  Each pin widget can choose any input DACs and a mixer.
17203 * Each ADC is connected from a mixer of all inputs.  This makes possible
17204 * 6-channel independent captures.
17205 *
17206 * In addition, an independent DAC for the multi-playback (not used in this
17207 * driver yet).
17208 */
17209#define ALC662_DIGOUT_NID	0x06
17210#define ALC662_DIGIN_NID	0x0a
17211
17212static hda_nid_t alc662_dac_nids[4] = {
17213	/* front, rear, clfe, rear_surr */
17214	0x02, 0x03, 0x04
17215};
17216
17217static hda_nid_t alc272_dac_nids[2] = {
17218	0x02, 0x03
17219};
17220
17221static hda_nid_t alc662_adc_nids[2] = {
17222	/* ADC1-2 */
17223	0x09, 0x08
17224};
17225
17226static hda_nid_t alc272_adc_nids[1] = {
17227	/* ADC1-2 */
17228	0x08,
17229};
17230
17231static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17232static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17233
17234
17235/* input MUX */
17236/* FIXME: should be a matrix-type input source selection */
17237static struct hda_input_mux alc662_capture_source = {
17238	.num_items = 4,
17239	.items = {
17240		{ "Mic", 0x0 },
17241		{ "Front Mic", 0x1 },
17242		{ "Line", 0x2 },
17243		{ "CD", 0x4 },
17244	},
17245};
17246
17247static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17248	.num_items = 2,
17249	.items = {
17250		{ "Mic", 0x1 },
17251		{ "Line", 0x2 },
17252	},
17253};
17254
17255static struct hda_input_mux alc663_capture_source = {
17256	.num_items = 3,
17257	.items = {
17258		{ "Mic", 0x0 },
17259		{ "Front Mic", 0x1 },
17260		{ "Line", 0x2 },
17261	},
17262};
17263
17264#if 0 /* set to 1 for testing other input sources below */
17265static struct hda_input_mux alc272_nc10_capture_source = {
17266	.num_items = 16,
17267	.items = {
17268		{ "Autoselect Mic", 0x0 },
17269		{ "Internal Mic", 0x1 },
17270		{ "In-0x02", 0x2 },
17271		{ "In-0x03", 0x3 },
17272		{ "In-0x04", 0x4 },
17273		{ "In-0x05", 0x5 },
17274		{ "In-0x06", 0x6 },
17275		{ "In-0x07", 0x7 },
17276		{ "In-0x08", 0x8 },
17277		{ "In-0x09", 0x9 },
17278		{ "In-0x0a", 0x0a },
17279		{ "In-0x0b", 0x0b },
17280		{ "In-0x0c", 0x0c },
17281		{ "In-0x0d", 0x0d },
17282		{ "In-0x0e", 0x0e },
17283		{ "In-0x0f", 0x0f },
17284	},
17285};
17286#endif
17287
17288/*
17289 * 2ch mode
17290 */
17291static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17292	{ 2, NULL }
17293};
17294
17295/*
17296 * 2ch mode
17297 */
17298static struct hda_verb alc662_3ST_ch2_init[] = {
17299	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17300	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17301	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17302	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17303	{ } /* end */
17304};
17305
17306/*
17307 * 6ch mode
17308 */
17309static struct hda_verb alc662_3ST_ch6_init[] = {
17310	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17311	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17312	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17313	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17314	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17315	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17316	{ } /* end */
17317};
17318
17319static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17320	{ 2, alc662_3ST_ch2_init },
17321	{ 6, alc662_3ST_ch6_init },
17322};
17323
17324/*
17325 * 2ch mode
17326 */
17327static struct hda_verb alc662_sixstack_ch6_init[] = {
17328	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17329	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17330	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17331	{ } /* end */
17332};
17333
17334/*
17335 * 6ch mode
17336 */
17337static struct hda_verb alc662_sixstack_ch8_init[] = {
17338	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17339	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17340	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17341	{ } /* end */
17342};
17343
17344static struct hda_channel_mode alc662_5stack_modes[2] = {
17345	{ 2, alc662_sixstack_ch6_init },
17346	{ 6, alc662_sixstack_ch8_init },
17347};
17348
17349/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17350 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17351 */
17352
17353static struct snd_kcontrol_new alc662_base_mixer[] = {
17354	/* output mixer control */
17355	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17356	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17357	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17358	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17359	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17360	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17361	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17362	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17363	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17364
17365	/*Input mixer control */
17366	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17367	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17368	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17369	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17370	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17371	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17372	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17373	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17374	{ } /* end */
17375};
17376
17377static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17378	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17379	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17380	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17381	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17382	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17383	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17384	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17385	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17386	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17387	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17388	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17389	{ } /* end */
17390};
17391
17392static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17393	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17394	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17395	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17396	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17397	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17398	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17399	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17400	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17401	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17402	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17403	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17404	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17405	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17406	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17407	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17408	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17409	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17410	{ } /* end */
17411};
17412
17413static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17414	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17415	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17416	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17417	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17418	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17419	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17420	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17421	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17422	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17423	{ } /* end */
17424};
17425
17426static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17427	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17428	ALC262_HIPPO_MASTER_SWITCH,
17429
17430	HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
17431	HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17432	HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17433
17434	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17435	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17436	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17437	{ } /* end */
17438};
17439
17440static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17441	ALC262_HIPPO_MASTER_SWITCH,
17442	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17443	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17444	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17445	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17446	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17447	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17448	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17449	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17450	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17451	{ } /* end */
17452};
17453
17454static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17455	.ops = &snd_hda_bind_vol,
17456	.values = {
17457		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17458		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17459		0
17460	},
17461};
17462
17463static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17464	.ops = &snd_hda_bind_sw,
17465	.values = {
17466		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17467		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17468		0
17469	},
17470};
17471
17472static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17473	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17474	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17475	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17476	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17477	{ } /* end */
17478};
17479
17480static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17481	.ops = &snd_hda_bind_sw,
17482	.values = {
17483		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17484		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17485		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17486		0
17487	},
17488};
17489
17490static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17491	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17492	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17493	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17494	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17495	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17496	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17497
17498	{ } /* end */
17499};
17500
17501static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17502	.ops = &snd_hda_bind_sw,
17503	.values = {
17504		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17505		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17506		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17507		0
17508	},
17509};
17510
17511static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17512	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17513	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17514	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17515	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17516	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17517	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17518	{ } /* end */
17519};
17520
17521static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17522	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17523	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17524	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17525	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17526	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17527	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17528	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17529	{ } /* end */
17530};
17531
17532static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17533	.ops = &snd_hda_bind_vol,
17534	.values = {
17535		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17536		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17537		0
17538	},
17539};
17540
17541static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17542	.ops = &snd_hda_bind_sw,
17543	.values = {
17544		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17545		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17546		0
17547	},
17548};
17549
17550static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17551	HDA_BIND_VOL("Master Playback Volume",
17552				&alc663_asus_two_bind_master_vol),
17553	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17554	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17555	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17556	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17557	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17558	{ } /* end */
17559};
17560
17561static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17562	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17563	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17564	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17565	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17566	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17567	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17568	{ } /* end */
17569};
17570
17571static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17572	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17573	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17574	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17575	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17576	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17577
17578	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17579	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17580	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17581	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17582	{ } /* end */
17583};
17584
17585static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17586	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17587	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17588	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17589
17590	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17591	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17592	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17593	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17594	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17595	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17596	{ } /* end */
17597};
17598
17599static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17600	.ops = &snd_hda_bind_sw,
17601	.values = {
17602		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17603		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17604		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17605		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17606		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17607		0
17608	},
17609};
17610
17611static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17612	.ops = &snd_hda_bind_sw,
17613	.values = {
17614		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17615		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17616		0
17617	},
17618};
17619
17620static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17621	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17622	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17623	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17624	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17625	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17626	HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17627	HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17628	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17629	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17630	{ } /* end */
17631};
17632
17633static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17634	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17635	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17636	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17637	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17638	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17639	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17640	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17641	{ } /* end */
17642};
17643
17644
17645static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17646	{
17647		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17648		.name = "Channel Mode",
17649		.info = alc_ch_mode_info,
17650		.get = alc_ch_mode_get,
17651		.put = alc_ch_mode_put,
17652	},
17653	{ } /* end */
17654};
17655
17656static struct hda_verb alc662_init_verbs[] = {
17657	/* ADC: mute amp left and right */
17658	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17659	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17660
17661	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17662	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17663	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17664	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17665	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17666	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17667
17668	/* Front Pin: output 0 (0x0c) */
17669	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17670	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17671
17672	/* Rear Pin: output 1 (0x0d) */
17673	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17674	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17675
17676	/* CLFE Pin: output 2 (0x0e) */
17677	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17678	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17679
17680	/* Mic (rear) pin: input vref at 80% */
17681	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17682	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17683	/* Front Mic pin: input vref at 80% */
17684	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17685	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17686	/* Line In pin: input */
17687	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17688	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17689	/* Line-2 In: Headphone output (output 0 - 0x0c) */
17690	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17691	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17692	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17693	/* CD pin widget for input */
17694	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17695
17696	/* FIXME: use matrix-type input source selection */
17697	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17698	/* Input mixer */
17699	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17700	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17701
17702	/* always trun on EAPD */
17703	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17704	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17705
17706	{ }
17707};
17708
17709static struct hda_verb alc663_init_verbs[] = {
17710	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17711	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17712	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17713	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17714	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17715	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17716	{ }
17717};
17718
17719static struct hda_verb alc272_init_verbs[] = {
17720	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17721	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17722	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17723	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17724	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17725	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17726	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17727	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17728	{ }
17729};
17730
17731static struct hda_verb alc662_sue_init_verbs[] = {
17732	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17733	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17734	{}
17735};
17736
17737static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17738	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17739	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17740	{}
17741};
17742
17743/* Set Unsolicited Event*/
17744static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17745	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17746	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17747	{}
17748};
17749
17750static struct hda_verb alc663_m51va_init_verbs[] = {
17751	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17752	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17753	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17754	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17755	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17756	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17757	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17758	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17759	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17760	{}
17761};
17762
17763static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17764	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17765	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17766	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17767	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17768	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17769	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17770	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17771	{}
17772};
17773
17774static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17775	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17776	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17777	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17778	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17779	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17780	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17781	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17782	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17783	{}
17784};
17785
17786static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17787	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17788	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17789	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17790	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17791	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17792	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17793	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17794	{}
17795};
17796
17797static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17798	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17799	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17800	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17801	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
17802	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17803	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17804	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
17805	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17806	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17807	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17808	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17809	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17810	{}
17811};
17812
17813static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17814	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17815	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17816	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17817	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17818	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17819	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17820	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17821	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17822	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17823	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17824	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17825	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17826	{}
17827};
17828
17829static struct hda_verb alc663_g71v_init_verbs[] = {
17830	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17831	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17832	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17833
17834	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17835	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17836	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17837
17838	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17839	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17840	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17841	{}
17842};
17843
17844static struct hda_verb alc663_g50v_init_verbs[] = {
17845	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17846	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17847	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17848
17849	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17850	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17851	{}
17852};
17853
17854static struct hda_verb alc662_ecs_init_verbs[] = {
17855	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17856	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17857	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17858	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17859	{}
17860};
17861
17862static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17863	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17864	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17865	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17866	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17867	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17868	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17869	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17870	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17871	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17872	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17873	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17874	{}
17875};
17876
17877static struct hda_verb alc272_dell_init_verbs[] = {
17878	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17879	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17880	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17881	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17882	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17883	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17884	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17885	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17886	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17887	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17888	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17889	{}
17890};
17891
17892static struct hda_verb alc663_mode7_init_verbs[] = {
17893	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17894	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17895	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17896	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17897	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17898	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17899	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
17900	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17901	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17902	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17903	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17904	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17905	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17906	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17907	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17908	{}
17909};
17910
17911static struct hda_verb alc663_mode8_init_verbs[] = {
17912	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17913	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17914	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17915	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
17916	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17917	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17918	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17919	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17920	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17921	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17922	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17923	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17924	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17925	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17926	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17927	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17928	{}
17929};
17930
17931static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17932	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17933	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17934	{ } /* end */
17935};
17936
17937static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17938	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17939	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17940	{ } /* end */
17941};
17942
17943static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17944{
17945	unsigned int present;
17946	unsigned char bits;
17947
17948	present = snd_hda_jack_detect(codec, 0x14);
17949	bits = present ? HDA_AMP_MUTE : 0;
17950
17951	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17952				 HDA_AMP_MUTE, bits);
17953}
17954
17955static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17956{
17957	unsigned int present;
17958	unsigned char bits;
17959
17960 	present = snd_hda_jack_detect(codec, 0x1b);
17961	bits = present ? HDA_AMP_MUTE : 0;
17962
17963	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17964				 HDA_AMP_MUTE, bits);
17965	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17966				 HDA_AMP_MUTE, bits);
17967}
17968
17969static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17970					   unsigned int res)
17971{
17972	if ((res >> 26) == ALC880_HP_EVENT)
17973		alc662_lenovo_101e_all_automute(codec);
17974	if ((res >> 26) == ALC880_FRONT_EVENT)
17975		alc662_lenovo_101e_ispeaker_automute(codec);
17976}
17977
17978/* unsolicited event for HP jack sensing */
17979static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17980				     unsigned int res)
17981{
17982	if ((res >> 26) == ALC880_MIC_EVENT)
17983		alc_mic_automute(codec);
17984	else
17985		alc262_hippo_unsol_event(codec, res);
17986}
17987
17988static void alc662_eeepc_setup(struct hda_codec *codec)
17989{
17990	struct alc_spec *spec = codec->spec;
17991
17992	alc262_hippo1_setup(codec);
17993	spec->ext_mic.pin = 0x18;
17994	spec->ext_mic.mux_idx = 0;
17995	spec->int_mic.pin = 0x19;
17996	spec->int_mic.mux_idx = 1;
17997	spec->auto_mic = 1;
17998}
17999
18000static void alc662_eeepc_inithook(struct hda_codec *codec)
18001{
18002	alc262_hippo_automute(codec);
18003	alc_mic_automute(codec);
18004}
18005
18006static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18007{
18008	struct alc_spec *spec = codec->spec;
18009
18010	spec->autocfg.hp_pins[0] = 0x14;
18011	spec->autocfg.speaker_pins[0] = 0x1b;
18012}
18013
18014#define alc662_eeepc_ep20_inithook	alc262_hippo_master_update
18015
18016static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18017{
18018	unsigned int present;
18019	unsigned char bits;
18020
18021	present = snd_hda_jack_detect(codec, 0x21);
18022	bits = present ? HDA_AMP_MUTE : 0;
18023	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18024				 HDA_AMP_MUTE, bits);
18025	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18026				 HDA_AMP_MUTE, bits);
18027}
18028
18029static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18030{
18031	unsigned int present;
18032	unsigned char bits;
18033
18034	present = snd_hda_jack_detect(codec, 0x21);
18035	bits = present ? HDA_AMP_MUTE : 0;
18036	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18037				 HDA_AMP_MUTE, bits);
18038	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18039				 HDA_AMP_MUTE, bits);
18040	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18041				 HDA_AMP_MUTE, bits);
18042	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18043				 HDA_AMP_MUTE, bits);
18044}
18045
18046static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18047{
18048	unsigned int present;
18049	unsigned char bits;
18050
18051	present = snd_hda_jack_detect(codec, 0x15);
18052	bits = present ? HDA_AMP_MUTE : 0;
18053	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18054				 HDA_AMP_MUTE, bits);
18055	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18056				 HDA_AMP_MUTE, bits);
18057	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18058				 HDA_AMP_MUTE, bits);
18059	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18060				 HDA_AMP_MUTE, bits);
18061}
18062
18063static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18064{
18065	unsigned int present;
18066	unsigned char bits;
18067
18068	present = snd_hda_jack_detect(codec, 0x1b);
18069	bits = present ? 0 : PIN_OUT;
18070	snd_hda_codec_write(codec, 0x14, 0,
18071			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18072}
18073
18074static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18075{
18076	unsigned int present1, present2;
18077
18078	present1 = snd_hda_jack_detect(codec, 0x21);
18079	present2 = snd_hda_jack_detect(codec, 0x15);
18080
18081	if (present1 || present2) {
18082		snd_hda_codec_write_cache(codec, 0x14, 0,
18083			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18084	} else {
18085		snd_hda_codec_write_cache(codec, 0x14, 0,
18086			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18087	}
18088}
18089
18090static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18091{
18092	unsigned int present1, present2;
18093
18094	present1 = snd_hda_jack_detect(codec, 0x1b);
18095	present2 = snd_hda_jack_detect(codec, 0x15);
18096
18097	if (present1 || present2) {
18098		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18099					 HDA_AMP_MUTE, HDA_AMP_MUTE);
18100		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18101					 HDA_AMP_MUTE, HDA_AMP_MUTE);
18102	} else {
18103		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18104					 HDA_AMP_MUTE, 0);
18105		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18106					 HDA_AMP_MUTE, 0);
18107	}
18108}
18109
18110static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18111{
18112	unsigned int present1, present2;
18113
18114	present1 = snd_hda_codec_read(codec, 0x1b, 0,
18115			AC_VERB_GET_PIN_SENSE, 0)
18116			& AC_PINSENSE_PRESENCE;
18117	present2 = snd_hda_codec_read(codec, 0x21, 0,
18118			AC_VERB_GET_PIN_SENSE, 0)
18119			& AC_PINSENSE_PRESENCE;
18120
18121	if (present1 || present2) {
18122		snd_hda_codec_write_cache(codec, 0x14, 0,
18123			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18124		snd_hda_codec_write_cache(codec, 0x17, 0,
18125			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18126	} else {
18127		snd_hda_codec_write_cache(codec, 0x14, 0,
18128			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18129		snd_hda_codec_write_cache(codec, 0x17, 0,
18130			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18131	}
18132}
18133
18134static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18135{
18136	unsigned int present1, present2;
18137
18138	present1 = snd_hda_codec_read(codec, 0x21, 0,
18139			AC_VERB_GET_PIN_SENSE, 0)
18140			& AC_PINSENSE_PRESENCE;
18141	present2 = snd_hda_codec_read(codec, 0x15, 0,
18142			AC_VERB_GET_PIN_SENSE, 0)
18143			& AC_PINSENSE_PRESENCE;
18144
18145	if (present1 || present2) {
18146		snd_hda_codec_write_cache(codec, 0x14, 0,
18147			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18148		snd_hda_codec_write_cache(codec, 0x17, 0,
18149			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18150	} else {
18151		snd_hda_codec_write_cache(codec, 0x14, 0,
18152			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18153		snd_hda_codec_write_cache(codec, 0x17, 0,
18154			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18155	}
18156}
18157
18158static void alc663_m51va_unsol_event(struct hda_codec *codec,
18159					   unsigned int res)
18160{
18161	switch (res >> 26) {
18162	case ALC880_HP_EVENT:
18163		alc663_m51va_speaker_automute(codec);
18164		break;
18165	case ALC880_MIC_EVENT:
18166		alc_mic_automute(codec);
18167		break;
18168	}
18169}
18170
18171static void alc663_m51va_setup(struct hda_codec *codec)
18172{
18173	struct alc_spec *spec = codec->spec;
18174	spec->ext_mic.pin = 0x18;
18175	spec->ext_mic.mux_idx = 0;
18176	spec->int_mic.pin = 0x12;
18177	spec->int_mic.mux_idx = 9;
18178	spec->auto_mic = 1;
18179}
18180
18181static void alc663_m51va_inithook(struct hda_codec *codec)
18182{
18183	alc663_m51va_speaker_automute(codec);
18184	alc_mic_automute(codec);
18185}
18186
18187/* ***************** Mode1 ******************************/
18188#define alc663_mode1_unsol_event	alc663_m51va_unsol_event
18189
18190static void alc663_mode1_setup(struct hda_codec *codec)
18191{
18192	struct alc_spec *spec = codec->spec;
18193	spec->ext_mic.pin = 0x18;
18194	spec->ext_mic.mux_idx = 0;
18195	spec->int_mic.pin = 0x19;
18196	spec->int_mic.mux_idx = 1;
18197	spec->auto_mic = 1;
18198}
18199
18200#define alc663_mode1_inithook		alc663_m51va_inithook
18201
18202/* ***************** Mode2 ******************************/
18203static void alc662_mode2_unsol_event(struct hda_codec *codec,
18204					   unsigned int res)
18205{
18206	switch (res >> 26) {
18207	case ALC880_HP_EVENT:
18208		alc662_f5z_speaker_automute(codec);
18209		break;
18210	case ALC880_MIC_EVENT:
18211		alc_mic_automute(codec);
18212		break;
18213	}
18214}
18215
18216#define alc662_mode2_setup	alc663_mode1_setup
18217
18218static void alc662_mode2_inithook(struct hda_codec *codec)
18219{
18220	alc662_f5z_speaker_automute(codec);
18221	alc_mic_automute(codec);
18222}
18223/* ***************** Mode3 ******************************/
18224static void alc663_mode3_unsol_event(struct hda_codec *codec,
18225					   unsigned int res)
18226{
18227	switch (res >> 26) {
18228	case ALC880_HP_EVENT:
18229		alc663_two_hp_m1_speaker_automute(codec);
18230		break;
18231	case ALC880_MIC_EVENT:
18232		alc_mic_automute(codec);
18233		break;
18234	}
18235}
18236
18237#define alc663_mode3_setup	alc663_mode1_setup
18238
18239static void alc663_mode3_inithook(struct hda_codec *codec)
18240{
18241	alc663_two_hp_m1_speaker_automute(codec);
18242	alc_mic_automute(codec);
18243}
18244/* ***************** Mode4 ******************************/
18245static void alc663_mode4_unsol_event(struct hda_codec *codec,
18246					   unsigned int res)
18247{
18248	switch (res >> 26) {
18249	case ALC880_HP_EVENT:
18250		alc663_21jd_two_speaker_automute(codec);
18251		break;
18252	case ALC880_MIC_EVENT:
18253		alc_mic_automute(codec);
18254		break;
18255	}
18256}
18257
18258#define alc663_mode4_setup	alc663_mode1_setup
18259
18260static void alc663_mode4_inithook(struct hda_codec *codec)
18261{
18262	alc663_21jd_two_speaker_automute(codec);
18263	alc_mic_automute(codec);
18264}
18265/* ***************** Mode5 ******************************/
18266static void alc663_mode5_unsol_event(struct hda_codec *codec,
18267					   unsigned int res)
18268{
18269	switch (res >> 26) {
18270	case ALC880_HP_EVENT:
18271		alc663_15jd_two_speaker_automute(codec);
18272		break;
18273	case ALC880_MIC_EVENT:
18274		alc_mic_automute(codec);
18275		break;
18276	}
18277}
18278
18279#define alc663_mode5_setup	alc663_mode1_setup
18280
18281static void alc663_mode5_inithook(struct hda_codec *codec)
18282{
18283	alc663_15jd_two_speaker_automute(codec);
18284	alc_mic_automute(codec);
18285}
18286/* ***************** Mode6 ******************************/
18287static void alc663_mode6_unsol_event(struct hda_codec *codec,
18288					   unsigned int res)
18289{
18290	switch (res >> 26) {
18291	case ALC880_HP_EVENT:
18292		alc663_two_hp_m2_speaker_automute(codec);
18293		break;
18294	case ALC880_MIC_EVENT:
18295		alc_mic_automute(codec);
18296		break;
18297	}
18298}
18299
18300#define alc663_mode6_setup	alc663_mode1_setup
18301
18302static void alc663_mode6_inithook(struct hda_codec *codec)
18303{
18304	alc663_two_hp_m2_speaker_automute(codec);
18305	alc_mic_automute(codec);
18306}
18307
18308/* ***************** Mode7 ******************************/
18309static void alc663_mode7_unsol_event(struct hda_codec *codec,
18310					   unsigned int res)
18311{
18312	switch (res >> 26) {
18313	case ALC880_HP_EVENT:
18314		alc663_two_hp_m7_speaker_automute(codec);
18315		break;
18316	case ALC880_MIC_EVENT:
18317		alc_mic_automute(codec);
18318		break;
18319	}
18320}
18321
18322#define alc663_mode7_setup	alc663_mode1_setup
18323
18324static void alc663_mode7_inithook(struct hda_codec *codec)
18325{
18326	alc663_two_hp_m7_speaker_automute(codec);
18327	alc_mic_automute(codec);
18328}
18329
18330/* ***************** Mode8 ******************************/
18331static void alc663_mode8_unsol_event(struct hda_codec *codec,
18332					   unsigned int res)
18333{
18334	switch (res >> 26) {
18335	case ALC880_HP_EVENT:
18336		alc663_two_hp_m8_speaker_automute(codec);
18337		break;
18338	case ALC880_MIC_EVENT:
18339		alc_mic_automute(codec);
18340		break;
18341	}
18342}
18343
18344#define alc663_mode8_setup	alc663_m51va_setup
18345
18346static void alc663_mode8_inithook(struct hda_codec *codec)
18347{
18348	alc663_two_hp_m8_speaker_automute(codec);
18349	alc_mic_automute(codec);
18350}
18351
18352static void alc663_g71v_hp_automute(struct hda_codec *codec)
18353{
18354	unsigned int present;
18355	unsigned char bits;
18356
18357	present = snd_hda_jack_detect(codec, 0x21);
18358	bits = present ? HDA_AMP_MUTE : 0;
18359	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18360				 HDA_AMP_MUTE, bits);
18361	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18362				 HDA_AMP_MUTE, bits);
18363}
18364
18365static void alc663_g71v_front_automute(struct hda_codec *codec)
18366{
18367	unsigned int present;
18368	unsigned char bits;
18369
18370	present = snd_hda_jack_detect(codec, 0x15);
18371	bits = present ? HDA_AMP_MUTE : 0;
18372	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18373				 HDA_AMP_MUTE, bits);
18374}
18375
18376static void alc663_g71v_unsol_event(struct hda_codec *codec,
18377					   unsigned int res)
18378{
18379	switch (res >> 26) {
18380	case ALC880_HP_EVENT:
18381		alc663_g71v_hp_automute(codec);
18382		break;
18383	case ALC880_FRONT_EVENT:
18384		alc663_g71v_front_automute(codec);
18385		break;
18386	case ALC880_MIC_EVENT:
18387		alc_mic_automute(codec);
18388		break;
18389	}
18390}
18391
18392#define alc663_g71v_setup	alc663_m51va_setup
18393
18394static void alc663_g71v_inithook(struct hda_codec *codec)
18395{
18396	alc663_g71v_front_automute(codec);
18397	alc663_g71v_hp_automute(codec);
18398	alc_mic_automute(codec);
18399}
18400
18401static void alc663_g50v_unsol_event(struct hda_codec *codec,
18402					   unsigned int res)
18403{
18404	switch (res >> 26) {
18405	case ALC880_HP_EVENT:
18406		alc663_m51va_speaker_automute(codec);
18407		break;
18408	case ALC880_MIC_EVENT:
18409		alc_mic_automute(codec);
18410		break;
18411	}
18412}
18413
18414#define alc663_g50v_setup	alc663_m51va_setup
18415
18416static void alc663_g50v_inithook(struct hda_codec *codec)
18417{
18418	alc663_m51va_speaker_automute(codec);
18419	alc_mic_automute(codec);
18420}
18421
18422static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18423	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18424	ALC262_HIPPO_MASTER_SWITCH,
18425
18426	HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
18427	HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18428	HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18429
18430	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
18431	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18432	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18433	{ } /* end */
18434};
18435
18436static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18437	/* Master Playback automatically created from Speaker and Headphone */
18438	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18439	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18440	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18441	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18442
18443	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18444	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18445	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
18446
18447	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18448	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18449	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
18450	{ } /* end */
18451};
18452
18453#ifdef CONFIG_SND_HDA_POWER_SAVE
18454#define alc662_loopbacks	alc880_loopbacks
18455#endif
18456
18457
18458/* pcm configuration: identical with ALC880 */
18459#define alc662_pcm_analog_playback	alc880_pcm_analog_playback
18460#define alc662_pcm_analog_capture	alc880_pcm_analog_capture
18461#define alc662_pcm_digital_playback	alc880_pcm_digital_playback
18462#define alc662_pcm_digital_capture	alc880_pcm_digital_capture
18463
18464/*
18465 * configuration and preset
18466 */
18467static const char *alc662_models[ALC662_MODEL_LAST] = {
18468	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
18469	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
18470	[ALC662_3ST_6ch]	= "3stack-6ch",
18471	[ALC662_5ST_DIG]	= "6stack-dig",
18472	[ALC662_LENOVO_101E]	= "lenovo-101e",
18473	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18474	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18475	[ALC662_ECS] = "ecs",
18476	[ALC663_ASUS_M51VA] = "m51va",
18477	[ALC663_ASUS_G71V] = "g71v",
18478	[ALC663_ASUS_H13] = "h13",
18479	[ALC663_ASUS_G50V] = "g50v",
18480	[ALC663_ASUS_MODE1] = "asus-mode1",
18481	[ALC662_ASUS_MODE2] = "asus-mode2",
18482	[ALC663_ASUS_MODE3] = "asus-mode3",
18483	[ALC663_ASUS_MODE4] = "asus-mode4",
18484	[ALC663_ASUS_MODE5] = "asus-mode5",
18485	[ALC663_ASUS_MODE6] = "asus-mode6",
18486	[ALC663_ASUS_MODE7] = "asus-mode7",
18487	[ALC663_ASUS_MODE8] = "asus-mode8",
18488	[ALC272_DELL]		= "dell",
18489	[ALC272_DELL_ZM1]	= "dell-zm1",
18490	[ALC272_SAMSUNG_NC10]	= "samsung-nc10",
18491	[ALC662_AUTO]		= "auto",
18492};
18493
18494static struct snd_pci_quirk alc662_cfg_tbl[] = {
18495	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18496	SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18497	SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18498	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18499	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18500	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18501	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18502	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18503	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18504	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18505	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18506	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18507	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18508	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18509	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18510	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18511	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18512	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18513	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18514	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18515	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18516	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18517	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18518	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18519	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18520	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18521	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18522	SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18523	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18524	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18525	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18526	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18527	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18528	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18529	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18530	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18531	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18532	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18533	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18534	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18535	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18536	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18537	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18538	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18539	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18540	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18541	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18542	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18543	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18544	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18545	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18546	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18547	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18548	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18549	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18550	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18551	SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18552	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18553	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18554	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18555	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18556	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18557	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18558	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18559		      ALC662_3ST_6ch_DIG),
18560	SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18561	SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18562	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18563		      ALC662_3ST_6ch_DIG),
18564	SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18565	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18566	SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18567	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18568	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18569					ALC662_3ST_6ch_DIG),
18570	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18571			   ALC663_ASUS_H13),
18572	{}
18573};
18574
18575static struct alc_config_preset alc662_presets[] = {
18576	[ALC662_3ST_2ch_DIG] = {
18577		.mixers = { alc662_3ST_2ch_mixer },
18578		.init_verbs = { alc662_init_verbs },
18579		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18580		.dac_nids = alc662_dac_nids,
18581		.dig_out_nid = ALC662_DIGOUT_NID,
18582		.dig_in_nid = ALC662_DIGIN_NID,
18583		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18584		.channel_mode = alc662_3ST_2ch_modes,
18585		.input_mux = &alc662_capture_source,
18586	},
18587	[ALC662_3ST_6ch_DIG] = {
18588		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18589		.init_verbs = { alc662_init_verbs },
18590		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18591		.dac_nids = alc662_dac_nids,
18592		.dig_out_nid = ALC662_DIGOUT_NID,
18593		.dig_in_nid = ALC662_DIGIN_NID,
18594		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18595		.channel_mode = alc662_3ST_6ch_modes,
18596		.need_dac_fix = 1,
18597		.input_mux = &alc662_capture_source,
18598	},
18599	[ALC662_3ST_6ch] = {
18600		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18601		.init_verbs = { alc662_init_verbs },
18602		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18603		.dac_nids = alc662_dac_nids,
18604		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18605		.channel_mode = alc662_3ST_6ch_modes,
18606		.need_dac_fix = 1,
18607		.input_mux = &alc662_capture_source,
18608	},
18609	[ALC662_5ST_DIG] = {
18610		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
18611		.init_verbs = { alc662_init_verbs },
18612		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18613		.dac_nids = alc662_dac_nids,
18614		.dig_out_nid = ALC662_DIGOUT_NID,
18615		.dig_in_nid = ALC662_DIGIN_NID,
18616		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18617		.channel_mode = alc662_5stack_modes,
18618		.input_mux = &alc662_capture_source,
18619	},
18620	[ALC662_LENOVO_101E] = {
18621		.mixers = { alc662_lenovo_101e_mixer },
18622		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18623		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18624		.dac_nids = alc662_dac_nids,
18625		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18626		.channel_mode = alc662_3ST_2ch_modes,
18627		.input_mux = &alc662_lenovo_101e_capture_source,
18628		.unsol_event = alc662_lenovo_101e_unsol_event,
18629		.init_hook = alc662_lenovo_101e_all_automute,
18630	},
18631	[ALC662_ASUS_EEEPC_P701] = {
18632		.mixers = { alc662_eeepc_p701_mixer },
18633		.init_verbs = { alc662_init_verbs,
18634				alc662_eeepc_sue_init_verbs },
18635		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18636		.dac_nids = alc662_dac_nids,
18637		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18638		.channel_mode = alc662_3ST_2ch_modes,
18639		.unsol_event = alc662_eeepc_unsol_event,
18640		.setup = alc662_eeepc_setup,
18641		.init_hook = alc662_eeepc_inithook,
18642	},
18643	[ALC662_ASUS_EEEPC_EP20] = {
18644		.mixers = { alc662_eeepc_ep20_mixer,
18645			    alc662_chmode_mixer },
18646		.init_verbs = { alc662_init_verbs,
18647				alc662_eeepc_ep20_sue_init_verbs },
18648		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18649		.dac_nids = alc662_dac_nids,
18650		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18651		.channel_mode = alc662_3ST_6ch_modes,
18652		.input_mux = &alc662_lenovo_101e_capture_source,
18653		.unsol_event = alc662_eeepc_unsol_event,
18654		.setup = alc662_eeepc_ep20_setup,
18655		.init_hook = alc662_eeepc_ep20_inithook,
18656	},
18657	[ALC662_ECS] = {
18658		.mixers = { alc662_ecs_mixer },
18659		.init_verbs = { alc662_init_verbs,
18660				alc662_ecs_init_verbs },
18661		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18662		.dac_nids = alc662_dac_nids,
18663		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18664		.channel_mode = alc662_3ST_2ch_modes,
18665		.unsol_event = alc662_eeepc_unsol_event,
18666		.setup = alc662_eeepc_setup,
18667		.init_hook = alc662_eeepc_inithook,
18668	},
18669	[ALC663_ASUS_M51VA] = {
18670		.mixers = { alc663_m51va_mixer },
18671		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18672		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18673		.dac_nids = alc662_dac_nids,
18674		.dig_out_nid = ALC662_DIGOUT_NID,
18675		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18676		.channel_mode = alc662_3ST_2ch_modes,
18677		.unsol_event = alc663_m51va_unsol_event,
18678		.setup = alc663_m51va_setup,
18679		.init_hook = alc663_m51va_inithook,
18680	},
18681	[ALC663_ASUS_G71V] = {
18682		.mixers = { alc663_g71v_mixer },
18683		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18684		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18685		.dac_nids = alc662_dac_nids,
18686		.dig_out_nid = ALC662_DIGOUT_NID,
18687		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18688		.channel_mode = alc662_3ST_2ch_modes,
18689		.unsol_event = alc663_g71v_unsol_event,
18690		.setup = alc663_g71v_setup,
18691		.init_hook = alc663_g71v_inithook,
18692	},
18693	[ALC663_ASUS_H13] = {
18694		.mixers = { alc663_m51va_mixer },
18695		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18696		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18697		.dac_nids = alc662_dac_nids,
18698		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18699		.channel_mode = alc662_3ST_2ch_modes,
18700		.unsol_event = alc663_m51va_unsol_event,
18701		.init_hook = alc663_m51va_inithook,
18702	},
18703	[ALC663_ASUS_G50V] = {
18704		.mixers = { alc663_g50v_mixer },
18705		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18706		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18707		.dac_nids = alc662_dac_nids,
18708		.dig_out_nid = ALC662_DIGOUT_NID,
18709		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18710		.channel_mode = alc662_3ST_6ch_modes,
18711		.input_mux = &alc663_capture_source,
18712		.unsol_event = alc663_g50v_unsol_event,
18713		.setup = alc663_g50v_setup,
18714		.init_hook = alc663_g50v_inithook,
18715	},
18716	[ALC663_ASUS_MODE1] = {
18717		.mixers = { alc663_m51va_mixer },
18718		.cap_mixer = alc662_auto_capture_mixer,
18719		.init_verbs = { alc662_init_verbs,
18720				alc663_21jd_amic_init_verbs },
18721		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18722		.hp_nid = 0x03,
18723		.dac_nids = alc662_dac_nids,
18724		.dig_out_nid = ALC662_DIGOUT_NID,
18725		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18726		.channel_mode = alc662_3ST_2ch_modes,
18727		.unsol_event = alc663_mode1_unsol_event,
18728		.setup = alc663_mode1_setup,
18729		.init_hook = alc663_mode1_inithook,
18730	},
18731	[ALC662_ASUS_MODE2] = {
18732		.mixers = { alc662_1bjd_mixer },
18733		.cap_mixer = alc662_auto_capture_mixer,
18734		.init_verbs = { alc662_init_verbs,
18735				alc662_1bjd_amic_init_verbs },
18736		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18737		.dac_nids = alc662_dac_nids,
18738		.dig_out_nid = ALC662_DIGOUT_NID,
18739		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18740		.channel_mode = alc662_3ST_2ch_modes,
18741		.unsol_event = alc662_mode2_unsol_event,
18742		.setup = alc662_mode2_setup,
18743		.init_hook = alc662_mode2_inithook,
18744	},
18745	[ALC663_ASUS_MODE3] = {
18746		.mixers = { alc663_two_hp_m1_mixer },
18747		.cap_mixer = alc662_auto_capture_mixer,
18748		.init_verbs = { alc662_init_verbs,
18749				alc663_two_hp_amic_m1_init_verbs },
18750		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18751		.hp_nid = 0x03,
18752		.dac_nids = alc662_dac_nids,
18753		.dig_out_nid = ALC662_DIGOUT_NID,
18754		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18755		.channel_mode = alc662_3ST_2ch_modes,
18756		.unsol_event = alc663_mode3_unsol_event,
18757		.setup = alc663_mode3_setup,
18758		.init_hook = alc663_mode3_inithook,
18759	},
18760	[ALC663_ASUS_MODE4] = {
18761		.mixers = { alc663_asus_21jd_clfe_mixer },
18762		.cap_mixer = alc662_auto_capture_mixer,
18763		.init_verbs = { alc662_init_verbs,
18764				alc663_21jd_amic_init_verbs},
18765		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18766		.hp_nid = 0x03,
18767		.dac_nids = alc662_dac_nids,
18768		.dig_out_nid = ALC662_DIGOUT_NID,
18769		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18770		.channel_mode = alc662_3ST_2ch_modes,
18771		.unsol_event = alc663_mode4_unsol_event,
18772		.setup = alc663_mode4_setup,
18773		.init_hook = alc663_mode4_inithook,
18774	},
18775	[ALC663_ASUS_MODE5] = {
18776		.mixers = { alc663_asus_15jd_clfe_mixer },
18777		.cap_mixer = alc662_auto_capture_mixer,
18778		.init_verbs = { alc662_init_verbs,
18779				alc663_15jd_amic_init_verbs },
18780		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18781		.hp_nid = 0x03,
18782		.dac_nids = alc662_dac_nids,
18783		.dig_out_nid = ALC662_DIGOUT_NID,
18784		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18785		.channel_mode = alc662_3ST_2ch_modes,
18786		.unsol_event = alc663_mode5_unsol_event,
18787		.setup = alc663_mode5_setup,
18788		.init_hook = alc663_mode5_inithook,
18789	},
18790	[ALC663_ASUS_MODE6] = {
18791		.mixers = { alc663_two_hp_m2_mixer },
18792		.cap_mixer = alc662_auto_capture_mixer,
18793		.init_verbs = { alc662_init_verbs,
18794				alc663_two_hp_amic_m2_init_verbs },
18795		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18796		.hp_nid = 0x03,
18797		.dac_nids = alc662_dac_nids,
18798		.dig_out_nid = ALC662_DIGOUT_NID,
18799		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18800		.channel_mode = alc662_3ST_2ch_modes,
18801		.unsol_event = alc663_mode6_unsol_event,
18802		.setup = alc663_mode6_setup,
18803		.init_hook = alc663_mode6_inithook,
18804	},
18805	[ALC663_ASUS_MODE7] = {
18806		.mixers = { alc663_mode7_mixer },
18807		.cap_mixer = alc662_auto_capture_mixer,
18808		.init_verbs = { alc662_init_verbs,
18809				alc663_mode7_init_verbs },
18810		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18811		.hp_nid = 0x03,
18812		.dac_nids = alc662_dac_nids,
18813		.dig_out_nid = ALC662_DIGOUT_NID,
18814		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18815		.channel_mode = alc662_3ST_2ch_modes,
18816		.unsol_event = alc663_mode7_unsol_event,
18817		.setup = alc663_mode7_setup,
18818		.init_hook = alc663_mode7_inithook,
18819	},
18820	[ALC663_ASUS_MODE8] = {
18821		.mixers = { alc663_mode8_mixer },
18822		.cap_mixer = alc662_auto_capture_mixer,
18823		.init_verbs = { alc662_init_verbs,
18824				alc663_mode8_init_verbs },
18825		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18826		.hp_nid = 0x03,
18827		.dac_nids = alc662_dac_nids,
18828		.dig_out_nid = ALC662_DIGOUT_NID,
18829		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18830		.channel_mode = alc662_3ST_2ch_modes,
18831		.unsol_event = alc663_mode8_unsol_event,
18832		.setup = alc663_mode8_setup,
18833		.init_hook = alc663_mode8_inithook,
18834	},
18835	[ALC272_DELL] = {
18836		.mixers = { alc663_m51va_mixer },
18837		.cap_mixer = alc272_auto_capture_mixer,
18838		.init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18839		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18840		.dac_nids = alc662_dac_nids,
18841		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18842		.adc_nids = alc272_adc_nids,
18843		.num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18844		.capsrc_nids = alc272_capsrc_nids,
18845		.channel_mode = alc662_3ST_2ch_modes,
18846		.unsol_event = alc663_m51va_unsol_event,
18847		.setup = alc663_m51va_setup,
18848		.init_hook = alc663_m51va_inithook,
18849	},
18850	[ALC272_DELL_ZM1] = {
18851		.mixers = { alc663_m51va_mixer },
18852		.cap_mixer = alc662_auto_capture_mixer,
18853		.init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18854		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18855		.dac_nids = alc662_dac_nids,
18856		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18857		.adc_nids = alc662_adc_nids,
18858		.num_adc_nids = 1,
18859		.capsrc_nids = alc662_capsrc_nids,
18860		.channel_mode = alc662_3ST_2ch_modes,
18861		.unsol_event = alc663_m51va_unsol_event,
18862		.setup = alc663_m51va_setup,
18863		.init_hook = alc663_m51va_inithook,
18864	},
18865	[ALC272_SAMSUNG_NC10] = {
18866		.mixers = { alc272_nc10_mixer },
18867		.init_verbs = { alc662_init_verbs,
18868				alc663_21jd_amic_init_verbs },
18869		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18870		.dac_nids = alc272_dac_nids,
18871		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18872		.channel_mode = alc662_3ST_2ch_modes,
18873		/*.input_mux = &alc272_nc10_capture_source,*/
18874		.unsol_event = alc663_mode4_unsol_event,
18875		.setup = alc663_mode4_setup,
18876		.init_hook = alc663_mode4_inithook,
18877	},
18878};
18879
18880
18881/*
18882 * BIOS auto configuration
18883 */
18884
18885/* convert from MIX nid to DAC */
18886static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18887{
18888	if (nid == 0x0f)
18889		return 0x02;
18890	else if (nid >= 0x0c && nid <= 0x0e)
18891		return nid - 0x0c + 0x02;
18892	else
18893		return 0;
18894}
18895
18896/* get MIX nid connected to the given pin targeted to DAC */
18897static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18898				   hda_nid_t dac)
18899{
18900	hda_nid_t mix[4];
18901	int i, num;
18902
18903	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18904	for (i = 0; i < num; i++) {
18905		if (alc662_mix_to_dac(mix[i]) == dac)
18906			return mix[i];
18907	}
18908	return 0;
18909}
18910
18911/* look for an empty DAC slot */
18912static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18913{
18914	struct alc_spec *spec = codec->spec;
18915	hda_nid_t srcs[5];
18916	int i, j, num;
18917
18918	num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18919	if (num < 0)
18920		return 0;
18921	for (i = 0; i < num; i++) {
18922		hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18923		if (!nid)
18924			continue;
18925		for (j = 0; j < spec->multiout.num_dacs; j++)
18926			if (spec->multiout.dac_nids[j] == nid)
18927				break;
18928		if (j >= spec->multiout.num_dacs)
18929			return nid;
18930	}
18931	return 0;
18932}
18933
18934/* fill in the dac_nids table from the parsed pin configuration */
18935static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18936				     const struct auto_pin_cfg *cfg)
18937{
18938	struct alc_spec *spec = codec->spec;
18939	int i;
18940	hda_nid_t dac;
18941
18942	spec->multiout.dac_nids = spec->private_dac_nids;
18943	for (i = 0; i < cfg->line_outs; i++) {
18944		dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18945		if (!dac)
18946			continue;
18947		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18948	}
18949	return 0;
18950}
18951
18952static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18953			      hda_nid_t nid, unsigned int chs)
18954{
18955	return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18956			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18957}
18958
18959static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18960			     hda_nid_t nid, unsigned int chs)
18961{
18962	return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18963			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18964}
18965
18966#define alc662_add_stereo_vol(spec, pfx, nid) \
18967	alc662_add_vol_ctl(spec, pfx, nid, 3)
18968#define alc662_add_stereo_sw(spec, pfx, nid) \
18969	alc662_add_sw_ctl(spec, pfx, nid, 3)
18970
18971/* add playback controls from the parsed DAC table */
18972static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18973					     const struct auto_pin_cfg *cfg)
18974{
18975	struct alc_spec *spec = codec->spec;
18976	static const char *chname[4] = {
18977		"Front", "Surround", NULL /*CLFE*/, "Side"
18978	};
18979	hda_nid_t nid, mix;
18980	int i, err;
18981
18982	for (i = 0; i < cfg->line_outs; i++) {
18983		nid = spec->multiout.dac_nids[i];
18984		if (!nid)
18985			continue;
18986		mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18987		if (!mix)
18988			continue;
18989		if (i == 2) {
18990			/* Center/LFE */
18991			err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18992			if (err < 0)
18993				return err;
18994			err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
18995			if (err < 0)
18996				return err;
18997			err = alc662_add_sw_ctl(spec, "Center", mix, 1);
18998			if (err < 0)
18999				return err;
19000			err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19001			if (err < 0)
19002				return err;
19003		} else {
19004			const char *pfx;
19005			if (cfg->line_outs == 1 &&
19006			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
19007				if (cfg->hp_outs)
19008					pfx = "Speaker";
19009				else
19010					pfx = "PCM";
19011			} else
19012				pfx = chname[i];
19013			err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19014			if (err < 0)
19015				return err;
19016			if (cfg->line_outs == 1 &&
19017			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19018				pfx = "Speaker";
19019			err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19020			if (err < 0)
19021				return err;
19022		}
19023	}
19024	return 0;
19025}
19026
19027/* add playback controls for speaker and HP outputs */
19028/* return DAC nid if any new DAC is assigned */
19029static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19030					const char *pfx)
19031{
19032	struct alc_spec *spec = codec->spec;
19033	hda_nid_t nid, mix;
19034	int err;
19035
19036	if (!pin)
19037		return 0;
19038	nid = alc662_look_for_dac(codec, pin);
19039	if (!nid) {
19040		/* the corresponding DAC is already occupied */
19041		if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19042			return 0; /* no way */
19043		/* create a switch only */
19044		return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19045				   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19046	}
19047
19048	mix = alc662_dac_to_mix(codec, pin, nid);
19049	if (!mix)
19050		return 0;
19051	err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19052	if (err < 0)
19053		return err;
19054	err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19055	if (err < 0)
19056		return err;
19057	return nid;
19058}
19059
19060/* create playback/capture controls for input pins */
19061#define alc662_auto_create_input_ctls \
19062	alc882_auto_create_input_ctls
19063
19064static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19065					      hda_nid_t nid, int pin_type,
19066					      hda_nid_t dac)
19067{
19068	int i, num;
19069	hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19070
19071	alc_set_pin_output(codec, nid, pin_type);
19072	/* need the manual connection? */
19073	num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19074	if (num <= 1)
19075		return;
19076	for (i = 0; i < num; i++) {
19077		if (alc662_mix_to_dac(srcs[i]) != dac)
19078			continue;
19079		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19080		return;
19081	}
19082}
19083
19084static void alc662_auto_init_multi_out(struct hda_codec *codec)
19085{
19086	struct alc_spec *spec = codec->spec;
19087	int pin_type = get_pin_type(spec->autocfg.line_out_type);
19088	int i;
19089
19090	for (i = 0; i <= HDA_SIDE; i++) {
19091		hda_nid_t nid = spec->autocfg.line_out_pins[i];
19092		if (nid)
19093			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19094					spec->multiout.dac_nids[i]);
19095	}
19096}
19097
19098static void alc662_auto_init_hp_out(struct hda_codec *codec)
19099{
19100	struct alc_spec *spec = codec->spec;
19101	hda_nid_t pin;
19102
19103	pin = spec->autocfg.hp_pins[0];
19104	if (pin)
19105		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19106						  spec->multiout.hp_nid);
19107	pin = spec->autocfg.speaker_pins[0];
19108	if (pin)
19109		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19110					spec->multiout.extra_out_nid[0]);
19111}
19112
19113#define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
19114
19115static void alc662_auto_init_analog_input(struct hda_codec *codec)
19116{
19117	struct alc_spec *spec = codec->spec;
19118	struct auto_pin_cfg *cfg = &spec->autocfg;
19119	int i;
19120
19121	for (i = 0; i < cfg->num_inputs; i++) {
19122		hda_nid_t nid = cfg->inputs[i].pin;
19123		if (alc_is_input_pin(codec, nid)) {
19124			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19125			if (nid != ALC662_PIN_CD_NID &&
19126			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19127				snd_hda_codec_write(codec, nid, 0,
19128						    AC_VERB_SET_AMP_GAIN_MUTE,
19129						    AMP_OUT_MUTE);
19130		}
19131	}
19132}
19133
19134#define alc662_auto_init_input_src	alc882_auto_init_input_src
19135
19136static int alc662_parse_auto_config(struct hda_codec *codec)
19137{
19138	struct alc_spec *spec = codec->spec;
19139	int err;
19140	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19141
19142	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19143					   alc662_ignore);
19144	if (err < 0)
19145		return err;
19146	if (!spec->autocfg.line_outs)
19147		return 0; /* can't find valid BIOS pin config */
19148
19149	err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19150	if (err < 0)
19151		return err;
19152	err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19153	if (err < 0)
19154		return err;
19155	err = alc662_auto_create_extra_out(codec,
19156					   spec->autocfg.speaker_pins[0],
19157					   "Speaker");
19158	if (err < 0)
19159		return err;
19160	if (err)
19161		spec->multiout.extra_out_nid[0] = err;
19162	err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19163					   "Headphone");
19164	if (err < 0)
19165		return err;
19166	if (err)
19167		spec->multiout.hp_nid = err;
19168	err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19169	if (err < 0)
19170		return err;
19171
19172	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19173
19174	alc_auto_parse_digital(codec);
19175
19176	if (spec->kctls.list)
19177		add_mixer(spec, spec->kctls.list);
19178
19179	spec->num_mux_defs = 1;
19180	spec->input_mux = &spec->private_imux[0];
19181
19182	add_verb(spec, alc662_init_verbs);
19183	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19184	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19185		add_verb(spec, alc663_init_verbs);
19186
19187	if (codec->vendor_id == 0x10ec0272)
19188		add_verb(spec, alc272_init_verbs);
19189
19190	err = alc_auto_add_mic_boost(codec);
19191	if (err < 0)
19192		return err;
19193
19194	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19195	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19196	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19197	else
19198	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19199
19200	return 1;
19201}
19202
19203/* additional initialization for auto-configuration model */
19204static void alc662_auto_init(struct hda_codec *codec)
19205{
19206	struct alc_spec *spec = codec->spec;
19207	alc662_auto_init_multi_out(codec);
19208	alc662_auto_init_hp_out(codec);
19209	alc662_auto_init_analog_input(codec);
19210	alc662_auto_init_input_src(codec);
19211	alc_auto_init_digital(codec);
19212	if (spec->unsol_event)
19213		alc_inithook(codec);
19214}
19215
19216enum {
19217	ALC662_FIXUP_IDEAPAD,
19218};
19219
19220static const struct alc_fixup alc662_fixups[] = {
19221	[ALC662_FIXUP_IDEAPAD] = {
19222		.pins = (const struct alc_pincfg[]) {
19223			{ 0x17, 0x99130112 }, /* subwoofer */
19224			{ }
19225		}
19226	},
19227};
19228
19229static struct snd_pci_quirk alc662_fixup_tbl[] = {
19230	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19231	{}
19232};
19233
19234
19235
19236static int patch_alc662(struct hda_codec *codec)
19237{
19238	struct alc_spec *spec;
19239	int err, board_config;
19240
19241	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19242	if (!spec)
19243		return -ENOMEM;
19244
19245	codec->spec = spec;
19246
19247	alc_auto_parse_customize_define(codec);
19248
19249	alc_fix_pll_init(codec, 0x20, 0x04, 15);
19250
19251	if (alc_read_coef_idx(codec, 0) == 0x8020)
19252		alc_codec_rename(codec, "ALC661");
19253	else if ((alc_read_coef_idx(codec, 0) & (1 << 14)) &&
19254		 codec->bus->pci->subsystem_vendor == 0x1025 &&
19255		 spec->cdefine.platform_type == 1)
19256		alc_codec_rename(codec, "ALC272X");
19257
19258	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19259						  alc662_models,
19260			  	                  alc662_cfg_tbl);
19261	if (board_config < 0) {
19262		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19263		       codec->chip_name);
19264		board_config = ALC662_AUTO;
19265	}
19266
19267	if (board_config == ALC662_AUTO) {
19268		alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1);
19269		/* automatic parse from the BIOS config */
19270		err = alc662_parse_auto_config(codec);
19271		if (err < 0) {
19272			alc_free(codec);
19273			return err;
19274		} else if (!err) {
19275			printk(KERN_INFO
19276			       "hda_codec: Cannot set up configuration "
19277			       "from BIOS.  Using base mode...\n");
19278			board_config = ALC662_3ST_2ch_DIG;
19279		}
19280	}
19281
19282	if (has_cdefine_beep(codec)) {
19283		err = snd_hda_attach_beep_device(codec, 0x1);
19284		if (err < 0) {
19285			alc_free(codec);
19286			return err;
19287		}
19288	}
19289
19290	if (board_config != ALC662_AUTO)
19291		setup_preset(codec, &alc662_presets[board_config]);
19292
19293	spec->stream_analog_playback = &alc662_pcm_analog_playback;
19294	spec->stream_analog_capture = &alc662_pcm_analog_capture;
19295
19296	spec->stream_digital_playback = &alc662_pcm_digital_playback;
19297	spec->stream_digital_capture = &alc662_pcm_digital_capture;
19298
19299	if (!spec->adc_nids) {
19300		spec->adc_nids = alc662_adc_nids;
19301		spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19302	}
19303	if (!spec->capsrc_nids)
19304		spec->capsrc_nids = alc662_capsrc_nids;
19305
19306	if (!spec->cap_mixer)
19307		set_capture_mixer(codec);
19308
19309	if (has_cdefine_beep(codec)) {
19310		switch (codec->vendor_id) {
19311		case 0x10ec0662:
19312			set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19313			break;
19314		case 0x10ec0272:
19315		case 0x10ec0663:
19316		case 0x10ec0665:
19317			set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19318			break;
19319		case 0x10ec0273:
19320			set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19321			break;
19322		}
19323	}
19324	spec->vmaster_nid = 0x02;
19325
19326	codec->patch_ops = alc_patch_ops;
19327	if (board_config == ALC662_AUTO) {
19328		spec->init_hook = alc662_auto_init;
19329		alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 0);
19330	}
19331
19332#ifdef CONFIG_SND_HDA_POWER_SAVE
19333	if (!spec->loopback.amplist)
19334		spec->loopback.amplist = alc662_loopbacks;
19335#endif
19336
19337	return 0;
19338}
19339
19340static int patch_alc888(struct hda_codec *codec)
19341{
19342	if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19343		kfree(codec->chip_name);
19344		codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19345		if (!codec->chip_name) {
19346			alc_free(codec);
19347			return -ENOMEM;
19348		}
19349		return patch_alc662(codec);
19350	}
19351	return patch_alc882(codec);
19352}
19353
19354/*
19355 * ALC680 support
19356 */
19357#define ALC680_DIGIN_NID	ALC880_DIGIN_NID
19358#define ALC680_DIGOUT_NID	ALC880_DIGOUT_NID
19359#define alc680_modes		alc260_modes
19360
19361static hda_nid_t alc680_dac_nids[3] = {
19362	/* Lout1, Lout2, hp */
19363	0x02, 0x03, 0x04
19364};
19365
19366static hda_nid_t alc680_adc_nids[3] = {
19367	/* ADC0-2 */
19368	/* DMIC, MIC, Line-in*/
19369	0x07, 0x08, 0x09
19370};
19371
19372/*
19373 * Analog capture ADC cgange
19374 */
19375static void alc680_rec_autoswitch(struct hda_codec *codec)
19376{
19377	struct alc_spec *spec = codec->spec;
19378	struct auto_pin_cfg *cfg = &spec->autocfg;
19379	int pin_found = 0;
19380	int type_found = AUTO_PIN_LAST;
19381	hda_nid_t nid;
19382	int i;
19383
19384	for (i = 0; i < cfg->num_inputs; i++) {
19385		nid = cfg->inputs[i].pin;
19386		if (!(snd_hda_query_pin_caps(codec, nid) &
19387		      AC_PINCAP_PRES_DETECT))
19388			continue;
19389		if (snd_hda_jack_detect(codec, nid)) {
19390			if (cfg->inputs[i].type < type_found) {
19391				type_found = cfg->inputs[i].type;
19392				pin_found = nid;
19393			}
19394		}
19395	}
19396
19397	nid = 0x07;
19398	if (pin_found)
19399		snd_hda_get_connections(codec, pin_found, &nid, 1);
19400
19401	if (nid != spec->cur_adc)
19402		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19403	spec->cur_adc = nid;
19404	snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19405				   spec->cur_adc_format);
19406}
19407
19408static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19409				      struct hda_codec *codec,
19410				      unsigned int stream_tag,
19411				      unsigned int format,
19412				      struct snd_pcm_substream *substream)
19413{
19414	struct alc_spec *spec = codec->spec;
19415
19416	spec->cur_adc = 0x07;
19417	spec->cur_adc_stream_tag = stream_tag;
19418	spec->cur_adc_format = format;
19419
19420	alc680_rec_autoswitch(codec);
19421	return 0;
19422}
19423
19424static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19425				      struct hda_codec *codec,
19426				      struct snd_pcm_substream *substream)
19427{
19428	snd_hda_codec_cleanup_stream(codec, 0x07);
19429	snd_hda_codec_cleanup_stream(codec, 0x08);
19430	snd_hda_codec_cleanup_stream(codec, 0x09);
19431	return 0;
19432}
19433
19434static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19435	.substreams = 1, /* can be overridden */
19436	.channels_min = 2,
19437	.channels_max = 2,
19438	/* NID is set in alc_build_pcms */
19439	.ops = {
19440		.prepare = alc680_capture_pcm_prepare,
19441		.cleanup = alc680_capture_pcm_cleanup
19442	},
19443};
19444
19445static struct snd_kcontrol_new alc680_base_mixer[] = {
19446	/* output mixer control */
19447	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19448	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19449	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19450	HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19451	HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
19452	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
19453	HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
19454	{ }
19455};
19456
19457static struct hda_bind_ctls alc680_bind_cap_vol = {
19458	.ops = &snd_hda_bind_vol,
19459	.values = {
19460		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19461		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19462		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19463		0
19464	},
19465};
19466
19467static struct hda_bind_ctls alc680_bind_cap_switch = {
19468	.ops = &snd_hda_bind_sw,
19469	.values = {
19470		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19471		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19472		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19473		0
19474	},
19475};
19476
19477static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19478	HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19479	HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19480	{ } /* end */
19481};
19482
19483/*
19484 * generic initialization of ADC, input mixers and output mixers
19485 */
19486static struct hda_verb alc680_init_verbs[] = {
19487	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19488	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19489	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19490
19491	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19492	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19493	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19494	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19495	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19496	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19497
19498	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19499	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19500	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19501	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19502	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19503
19504	{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19505	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19506	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19507
19508	{ }
19509};
19510
19511/* toggle speaker-output according to the hp-jack state */
19512static void alc680_base_setup(struct hda_codec *codec)
19513{
19514	struct alc_spec *spec = codec->spec;
19515
19516	spec->autocfg.hp_pins[0] = 0x16;
19517	spec->autocfg.speaker_pins[0] = 0x14;
19518	spec->autocfg.speaker_pins[1] = 0x15;
19519	spec->autocfg.num_inputs = 2;
19520	spec->autocfg.inputs[0].pin = 0x18;
19521	spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19522	spec->autocfg.inputs[1].pin = 0x19;
19523	spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19524}
19525
19526static void alc680_unsol_event(struct hda_codec *codec,
19527					   unsigned int res)
19528{
19529	if ((res >> 26) == ALC880_HP_EVENT)
19530		alc_automute_amp(codec);
19531	if ((res >> 26) == ALC880_MIC_EVENT)
19532		alc680_rec_autoswitch(codec);
19533}
19534
19535static void alc680_inithook(struct hda_codec *codec)
19536{
19537	alc_automute_amp(codec);
19538	alc680_rec_autoswitch(codec);
19539}
19540
19541/* create input playback/capture controls for the given pin */
19542static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19543				    const char *ctlname, int idx)
19544{
19545	hda_nid_t dac;
19546	int err;
19547
19548	switch (nid) {
19549	case 0x14:
19550		dac = 0x02;
19551		break;
19552	case 0x15:
19553		dac = 0x03;
19554		break;
19555	case 0x16:
19556		dac = 0x04;
19557		break;
19558	default:
19559		return 0;
19560	}
19561	if (spec->multiout.dac_nids[0] != dac &&
19562	    spec->multiout.dac_nids[1] != dac) {
19563		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19564				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19565						      HDA_OUTPUT));
19566		if (err < 0)
19567			return err;
19568
19569		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19570			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19571
19572		if (err < 0)
19573			return err;
19574		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19575	}
19576
19577	return 0;
19578}
19579
19580/* add playback controls from the parsed DAC table */
19581static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19582					     const struct auto_pin_cfg *cfg)
19583{
19584	hda_nid_t nid;
19585	int err;
19586
19587	spec->multiout.dac_nids = spec->private_dac_nids;
19588
19589	nid = cfg->line_out_pins[0];
19590	if (nid) {
19591		const char *name;
19592		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19593			name = "Speaker";
19594		else
19595			name = "Front";
19596		err = alc680_new_analog_output(spec, nid, name, 0);
19597		if (err < 0)
19598			return err;
19599	}
19600
19601	nid = cfg->speaker_pins[0];
19602	if (nid) {
19603		err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19604		if (err < 0)
19605			return err;
19606	}
19607	nid = cfg->hp_pins[0];
19608	if (nid) {
19609		err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19610		if (err < 0)
19611			return err;
19612	}
19613
19614	return 0;
19615}
19616
19617static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19618					      hda_nid_t nid, int pin_type)
19619{
19620	alc_set_pin_output(codec, nid, pin_type);
19621}
19622
19623static void alc680_auto_init_multi_out(struct hda_codec *codec)
19624{
19625	struct alc_spec *spec = codec->spec;
19626	hda_nid_t nid = spec->autocfg.line_out_pins[0];
19627	if (nid) {
19628		int pin_type = get_pin_type(spec->autocfg.line_out_type);
19629		alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19630	}
19631}
19632
19633static void alc680_auto_init_hp_out(struct hda_codec *codec)
19634{
19635	struct alc_spec *spec = codec->spec;
19636	hda_nid_t pin;
19637
19638	pin = spec->autocfg.hp_pins[0];
19639	if (pin)
19640		alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19641	pin = spec->autocfg.speaker_pins[0];
19642	if (pin)
19643		alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19644}
19645
19646/* pcm configuration: identical with ALC880 */
19647#define alc680_pcm_analog_playback	alc880_pcm_analog_playback
19648#define alc680_pcm_analog_capture	alc880_pcm_analog_capture
19649#define alc680_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
19650#define alc680_pcm_digital_playback	alc880_pcm_digital_playback
19651#define alc680_pcm_digital_capture	alc880_pcm_digital_capture
19652
19653/*
19654 * BIOS auto configuration
19655 */
19656static int alc680_parse_auto_config(struct hda_codec *codec)
19657{
19658	struct alc_spec *spec = codec->spec;
19659	int err;
19660	static hda_nid_t alc680_ignore[] = { 0 };
19661
19662	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19663					   alc680_ignore);
19664	if (err < 0)
19665		return err;
19666
19667	if (!spec->autocfg.line_outs) {
19668		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19669			spec->multiout.max_channels = 2;
19670			spec->no_analog = 1;
19671			goto dig_only;
19672		}
19673		return 0; /* can't find valid BIOS pin config */
19674	}
19675	err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19676	if (err < 0)
19677		return err;
19678
19679	spec->multiout.max_channels = 2;
19680
19681 dig_only:
19682	/* digital only support output */
19683	alc_auto_parse_digital(codec);
19684	if (spec->kctls.list)
19685		add_mixer(spec, spec->kctls.list);
19686
19687	add_verb(spec, alc680_init_verbs);
19688
19689	err = alc_auto_add_mic_boost(codec);
19690	if (err < 0)
19691		return err;
19692
19693	return 1;
19694}
19695
19696#define alc680_auto_init_analog_input	alc882_auto_init_analog_input
19697
19698/* init callback for auto-configuration model -- overriding the default init */
19699static void alc680_auto_init(struct hda_codec *codec)
19700{
19701	struct alc_spec *spec = codec->spec;
19702	alc680_auto_init_multi_out(codec);
19703	alc680_auto_init_hp_out(codec);
19704	alc680_auto_init_analog_input(codec);
19705	alc_auto_init_digital(codec);
19706	if (spec->unsol_event)
19707		alc_inithook(codec);
19708}
19709
19710/*
19711 * configuration and preset
19712 */
19713static const char *alc680_models[ALC680_MODEL_LAST] = {
19714	[ALC680_BASE]		= "base",
19715	[ALC680_AUTO]		= "auto",
19716};
19717
19718static struct snd_pci_quirk alc680_cfg_tbl[] = {
19719	SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19720	{}
19721};
19722
19723static struct alc_config_preset alc680_presets[] = {
19724	[ALC680_BASE] = {
19725		.mixers = { alc680_base_mixer },
19726		.cap_mixer =  alc680_master_capture_mixer,
19727		.init_verbs = { alc680_init_verbs },
19728		.num_dacs = ARRAY_SIZE(alc680_dac_nids),
19729		.dac_nids = alc680_dac_nids,
19730		.dig_out_nid = ALC680_DIGOUT_NID,
19731		.num_channel_mode = ARRAY_SIZE(alc680_modes),
19732		.channel_mode = alc680_modes,
19733		.unsol_event = alc680_unsol_event,
19734		.setup = alc680_base_setup,
19735		.init_hook = alc680_inithook,
19736
19737	},
19738};
19739
19740static int patch_alc680(struct hda_codec *codec)
19741{
19742	struct alc_spec *spec;
19743	int board_config;
19744	int err;
19745
19746	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19747	if (spec == NULL)
19748		return -ENOMEM;
19749
19750	codec->spec = spec;
19751
19752	board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19753						  alc680_models,
19754						  alc680_cfg_tbl);
19755
19756	if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19757		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19758		       codec->chip_name);
19759		board_config = ALC680_AUTO;
19760	}
19761
19762	if (board_config == ALC680_AUTO) {
19763		/* automatic parse from the BIOS config */
19764		err = alc680_parse_auto_config(codec);
19765		if (err < 0) {
19766			alc_free(codec);
19767			return err;
19768		} else if (!err) {
19769			printk(KERN_INFO
19770			       "hda_codec: Cannot set up configuration "
19771			       "from BIOS.  Using base mode...\n");
19772			board_config = ALC680_BASE;
19773		}
19774	}
19775
19776	if (board_config != ALC680_AUTO)
19777		setup_preset(codec, &alc680_presets[board_config]);
19778
19779	spec->stream_analog_playback = &alc680_pcm_analog_playback;
19780	spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19781	spec->stream_digital_playback = &alc680_pcm_digital_playback;
19782	spec->stream_digital_capture = &alc680_pcm_digital_capture;
19783
19784	if (!spec->adc_nids) {
19785		spec->adc_nids = alc680_adc_nids;
19786		spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19787	}
19788
19789	if (!spec->cap_mixer)
19790		set_capture_mixer(codec);
19791
19792	spec->vmaster_nid = 0x02;
19793
19794	codec->patch_ops = alc_patch_ops;
19795	if (board_config == ALC680_AUTO)
19796		spec->init_hook = alc680_auto_init;
19797
19798	return 0;
19799}
19800
19801/*
19802 * patch entries
19803 */
19804static struct hda_codec_preset snd_hda_preset_realtek[] = {
19805	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
19806	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
19807	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
19808	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
19809	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
19810	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
19811	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
19812	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
19813	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
19814	  .patch = patch_alc861 },
19815	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
19816	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
19817	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
19818	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
19819	  .patch = patch_alc882 },
19820	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
19821	  .patch = patch_alc662 },
19822	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
19823	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
19824	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
19825	{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
19826	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
19827	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
19828	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
19829	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
19830	  .patch = patch_alc882 },
19831	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
19832	  .patch = patch_alc882 },
19833	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
19834	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
19835	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
19836	  .patch = patch_alc882 },
19837	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
19838	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
19839	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
19840	{} /* terminator */
19841};
19842
19843MODULE_ALIAS("snd-hda-codec-id:10ec*");
19844
19845MODULE_LICENSE("GPL");
19846MODULE_DESCRIPTION("Realtek HD-audio codec");
19847
19848static struct hda_codec_preset_list realtek_list = {
19849	.preset = snd_hda_preset_realtek,
19850	.owner = THIS_MODULE,
19851};
19852
19853static int __init patch_realtek_init(void)
19854{
19855	return snd_hda_add_codec_preset(&realtek_list);
19856}
19857
19858static void __exit patch_realtek_exit(void)
19859{
19860	snd_hda_delete_codec_preset(&realtek_list);
19861}
19862
19863module_init(patch_realtek_init)
19864module_exit(patch_realtek_exit)
19865