patch_realtek.c revision 2785591a9760c677a7ee6f541e751c23086f5bfd 
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	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
305};
306
307struct alc_spec {
308	/* codec parameterization */
309	struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
310	unsigned int num_mixers;
311	struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
312	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
313
314	const struct hda_verb *init_verbs[10];	/* initialization verbs
315						 * don't forget NULL
316						 * termination!
317						 */
318	unsigned int num_init_verbs;
319
320	char stream_name_analog[32];	/* analog PCM stream */
321	struct hda_pcm_stream *stream_analog_playback;
322	struct hda_pcm_stream *stream_analog_capture;
323	struct hda_pcm_stream *stream_analog_alt_playback;
324	struct hda_pcm_stream *stream_analog_alt_capture;
325
326	char stream_name_digital[32];	/* digital PCM stream */
327	struct hda_pcm_stream *stream_digital_playback;
328	struct hda_pcm_stream *stream_digital_capture;
329
330	/* playback */
331	struct hda_multi_out multiout;	/* playback set-up
332					 * max_channels, dacs must be set
333					 * dig_out_nid and hp_nid are optional
334					 */
335	hda_nid_t alt_dac_nid;
336	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
337	int dig_out_type;
338
339	/* capture */
340	unsigned int num_adc_nids;
341	hda_nid_t *adc_nids;
342	hda_nid_t *capsrc_nids;
343	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
344
345	/* capture setup for dynamic dual-adc switch */
346	unsigned int cur_adc_idx;
347	hda_nid_t cur_adc;
348	unsigned int cur_adc_stream_tag;
349	unsigned int cur_adc_format;
350
351	/* capture source */
352	unsigned int num_mux_defs;
353	const struct hda_input_mux *input_mux;
354	unsigned int cur_mux[3];
355	struct alc_mic_route ext_mic;
356	struct alc_mic_route int_mic;
357
358	/* channel model */
359	const struct hda_channel_mode *channel_mode;
360	int num_channel_mode;
361	int need_dac_fix;
362	int const_channel_count;
363	int ext_channel_count;
364
365	/* PCM information */
366	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
367
368	/* jack detection */
369	struct snd_array jacks;
370
371	/* dynamic controls, init_verbs and input_mux */
372	struct auto_pin_cfg autocfg;
373	struct alc_customize_define cdefine;
374	struct snd_array kctls;
375	struct hda_input_mux private_imux[3];
376	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
377	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
378	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
379
380	/* hooks */
381	void (*init_hook)(struct hda_codec *codec);
382	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
383#ifdef CONFIG_SND_HDA_POWER_SAVE
384	void (*power_hook)(struct hda_codec *codec);
385#endif
386
387	/* for pin sensing */
388	unsigned int sense_updated: 1;
389	unsigned int jack_present: 1;
390	unsigned int master_sw: 1;
391	unsigned int auto_mic:1;
392
393	/* other flags */
394	unsigned int no_analog :1; /* digital I/O only */
395	unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
396	int init_amp;
397	int codec_variant;	/* flag for other variants */
398
399	/* for virtual master */
400	hda_nid_t vmaster_nid;
401#ifdef CONFIG_SND_HDA_POWER_SAVE
402	struct hda_loopback_check loopback;
403#endif
404
405	/* for PLL fix */
406	hda_nid_t pll_nid;
407	unsigned int pll_coef_idx, pll_coef_bit;
408};
409
410/*
411 * configuration template - to be copied to the spec instance
412 */
413struct alc_config_preset {
414	struct snd_kcontrol_new *mixers[5]; /* should be identical size
415					     * with spec
416					     */
417	struct snd_kcontrol_new *cap_mixer; /* capture mixer */
418	const struct hda_verb *init_verbs[5];
419	unsigned int num_dacs;
420	hda_nid_t *dac_nids;
421	hda_nid_t dig_out_nid;		/* optional */
422	hda_nid_t hp_nid;		/* optional */
423	hda_nid_t *slave_dig_outs;
424	unsigned int num_adc_nids;
425	hda_nid_t *adc_nids;
426	hda_nid_t *capsrc_nids;
427	hda_nid_t dig_in_nid;
428	unsigned int num_channel_mode;
429	const struct hda_channel_mode *channel_mode;
430	int need_dac_fix;
431	int const_channel_count;
432	unsigned int num_mux_defs;
433	const struct hda_input_mux *input_mux;
434	void (*unsol_event)(struct hda_codec *, unsigned int);
435	void (*setup)(struct hda_codec *);
436	void (*init_hook)(struct hda_codec *);
437#ifdef CONFIG_SND_HDA_POWER_SAVE
438	struct hda_amp_list *loopbacks;
439	void (*power_hook)(struct hda_codec *codec);
440#endif
441};
442
443
444/*
445 * input MUX handling
446 */
447static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
448			     struct snd_ctl_elem_info *uinfo)
449{
450	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
451	struct alc_spec *spec = codec->spec;
452	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
453	if (mux_idx >= spec->num_mux_defs)
454		mux_idx = 0;
455	if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
456		mux_idx = 0;
457	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
458}
459
460static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
461			    struct snd_ctl_elem_value *ucontrol)
462{
463	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
464	struct alc_spec *spec = codec->spec;
465	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
466
467	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
468	return 0;
469}
470
471static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
472			    struct snd_ctl_elem_value *ucontrol)
473{
474	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
475	struct alc_spec *spec = codec->spec;
476	const struct hda_input_mux *imux;
477	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
478	unsigned int mux_idx;
479	hda_nid_t nid = spec->capsrc_nids ?
480		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
481	unsigned int type;
482
483	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
484	imux = &spec->input_mux[mux_idx];
485	if (!imux->num_items && mux_idx > 0)
486		imux = &spec->input_mux[0];
487
488	type = get_wcaps_type(get_wcaps(codec, nid));
489	if (type == AC_WID_AUD_MIX) {
490		/* Matrix-mixer style (e.g. ALC882) */
491		unsigned int *cur_val = &spec->cur_mux[adc_idx];
492		unsigned int i, idx;
493
494		idx = ucontrol->value.enumerated.item[0];
495		if (idx >= imux->num_items)
496			idx = imux->num_items - 1;
497		if (*cur_val == idx)
498			return 0;
499		for (i = 0; i < imux->num_items; i++) {
500			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
501			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
502						 imux->items[i].index,
503						 HDA_AMP_MUTE, v);
504		}
505		*cur_val = idx;
506		return 1;
507	} else {
508		/* MUX style (e.g. ALC880) */
509		return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
510					     &spec->cur_mux[adc_idx]);
511	}
512}
513
514/*
515 * channel mode setting
516 */
517static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
518			    struct snd_ctl_elem_info *uinfo)
519{
520	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
521	struct alc_spec *spec = codec->spec;
522	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
523				    spec->num_channel_mode);
524}
525
526static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
527			   struct snd_ctl_elem_value *ucontrol)
528{
529	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
530	struct alc_spec *spec = codec->spec;
531	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
532				   spec->num_channel_mode,
533				   spec->ext_channel_count);
534}
535
536static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
537			   struct snd_ctl_elem_value *ucontrol)
538{
539	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
540	struct alc_spec *spec = codec->spec;
541	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
542				      spec->num_channel_mode,
543				      &spec->ext_channel_count);
544	if (err >= 0 && !spec->const_channel_count) {
545		spec->multiout.max_channels = spec->ext_channel_count;
546		if (spec->need_dac_fix)
547			spec->multiout.num_dacs = spec->multiout.max_channels / 2;
548	}
549	return err;
550}
551
552/*
553 * Control the mode of pin widget settings via the mixer.  "pc" is used
554 * instead of "%" to avoid consequences of accidently treating the % as
555 * being part of a format specifier.  Maximum allowed length of a value is
556 * 63 characters plus NULL terminator.
557 *
558 * Note: some retasking pin complexes seem to ignore requests for input
559 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
560 * are requested.  Therefore order this list so that this behaviour will not
561 * cause problems when mixer clients move through the enum sequentially.
562 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
563 * March 2006.
564 */
565static char *alc_pin_mode_names[] = {
566	"Mic 50pc bias", "Mic 80pc bias",
567	"Line in", "Line out", "Headphone out",
568};
569static unsigned char alc_pin_mode_values[] = {
570	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
571};
572/* The control can present all 5 options, or it can limit the options based
573 * in the pin being assumed to be exclusively an input or an output pin.  In
574 * addition, "input" pins may or may not process the mic bias option
575 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
576 * accept requests for bias as of chip versions up to March 2006) and/or
577 * wiring in the computer.
578 */
579#define ALC_PIN_DIR_IN              0x00
580#define ALC_PIN_DIR_OUT             0x01
581#define ALC_PIN_DIR_INOUT           0x02
582#define ALC_PIN_DIR_IN_NOMICBIAS    0x03
583#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
584
585/* Info about the pin modes supported by the different pin direction modes.
586 * For each direction the minimum and maximum values are given.
587 */
588static signed char alc_pin_mode_dir_info[5][2] = {
589	{ 0, 2 },    /* ALC_PIN_DIR_IN */
590	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
591	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
592	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
593	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
594};
595#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
596#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
597#define alc_pin_mode_n_items(_dir) \
598	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
599
600static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
601			     struct snd_ctl_elem_info *uinfo)
602{
603	unsigned int item_num = uinfo->value.enumerated.item;
604	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
605
606	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
607	uinfo->count = 1;
608	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
609
610	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
611		item_num = alc_pin_mode_min(dir);
612	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
613	return 0;
614}
615
616static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
617			    struct snd_ctl_elem_value *ucontrol)
618{
619	unsigned int i;
620	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
621	hda_nid_t nid = kcontrol->private_value & 0xffff;
622	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
623	long *valp = ucontrol->value.integer.value;
624	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
625						 AC_VERB_GET_PIN_WIDGET_CONTROL,
626						 0x00);
627
628	/* Find enumerated value for current pinctl setting */
629	i = alc_pin_mode_min(dir);
630	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
631		i++;
632	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
633	return 0;
634}
635
636static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
637			    struct snd_ctl_elem_value *ucontrol)
638{
639	signed int change;
640	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
641	hda_nid_t nid = kcontrol->private_value & 0xffff;
642	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
643	long val = *ucontrol->value.integer.value;
644	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
645						 AC_VERB_GET_PIN_WIDGET_CONTROL,
646						 0x00);
647
648	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
649		val = alc_pin_mode_min(dir);
650
651	change = pinctl != alc_pin_mode_values[val];
652	if (change) {
653		/* Set pin mode to that requested */
654		snd_hda_codec_write_cache(codec, nid, 0,
655					  AC_VERB_SET_PIN_WIDGET_CONTROL,
656					  alc_pin_mode_values[val]);
657
658		/* Also enable the retasking pin's input/output as required
659		 * for the requested pin mode.  Enum values of 2 or less are
660		 * input modes.
661		 *
662		 * Dynamically switching the input/output buffers probably
663		 * reduces noise slightly (particularly on input) so we'll
664		 * do it.  However, having both input and output buffers
665		 * enabled simultaneously doesn't seem to be problematic if
666		 * this turns out to be necessary in the future.
667		 */
668		if (val <= 2) {
669			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
670						 HDA_AMP_MUTE, HDA_AMP_MUTE);
671			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
672						 HDA_AMP_MUTE, 0);
673		} else {
674			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
675						 HDA_AMP_MUTE, HDA_AMP_MUTE);
676			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
677						 HDA_AMP_MUTE, 0);
678		}
679	}
680	return change;
681}
682
683#define ALC_PIN_MODE(xname, nid, dir) \
684	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
685	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
686	  .info = alc_pin_mode_info, \
687	  .get = alc_pin_mode_get, \
688	  .put = alc_pin_mode_put, \
689	  .private_value = nid | (dir<<16) }
690
691/* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
692 * together using a mask with more than one bit set.  This control is
693 * currently used only by the ALC260 test model.  At this stage they are not
694 * needed for any "production" models.
695 */
696#ifdef CONFIG_SND_DEBUG
697#define alc_gpio_data_info	snd_ctl_boolean_mono_info
698
699static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
700			     struct snd_ctl_elem_value *ucontrol)
701{
702	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
703	hda_nid_t nid = kcontrol->private_value & 0xffff;
704	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
705	long *valp = ucontrol->value.integer.value;
706	unsigned int val = snd_hda_codec_read(codec, nid, 0,
707					      AC_VERB_GET_GPIO_DATA, 0x00);
708
709	*valp = (val & mask) != 0;
710	return 0;
711}
712static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
713			     struct snd_ctl_elem_value *ucontrol)
714{
715	signed int change;
716	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
717	hda_nid_t nid = kcontrol->private_value & 0xffff;
718	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
719	long val = *ucontrol->value.integer.value;
720	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
721						    AC_VERB_GET_GPIO_DATA,
722						    0x00);
723
724	/* Set/unset the masked GPIO bit(s) as needed */
725	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
726	if (val == 0)
727		gpio_data &= ~mask;
728	else
729		gpio_data |= mask;
730	snd_hda_codec_write_cache(codec, nid, 0,
731				  AC_VERB_SET_GPIO_DATA, gpio_data);
732
733	return change;
734}
735#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
736	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
737	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
738	  .info = alc_gpio_data_info, \
739	  .get = alc_gpio_data_get, \
740	  .put = alc_gpio_data_put, \
741	  .private_value = nid | (mask<<16) }
742#endif   /* CONFIG_SND_DEBUG */
743
744/* A switch control to allow the enabling of the digital IO pins on the
745 * ALC260.  This is incredibly simplistic; the intention of this control is
746 * to provide something in the test model allowing digital outputs to be
747 * identified if present.  If models are found which can utilise these
748 * outputs a more complete mixer control can be devised for those models if
749 * necessary.
750 */
751#ifdef CONFIG_SND_DEBUG
752#define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info
753
754static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
755			      struct snd_ctl_elem_value *ucontrol)
756{
757	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
758	hda_nid_t nid = kcontrol->private_value & 0xffff;
759	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
760	long *valp = ucontrol->value.integer.value;
761	unsigned int val = snd_hda_codec_read(codec, nid, 0,
762					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);
763
764	*valp = (val & mask) != 0;
765	return 0;
766}
767static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
768			      struct snd_ctl_elem_value *ucontrol)
769{
770	signed int change;
771	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
772	hda_nid_t nid = kcontrol->private_value & 0xffff;
773	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
774	long val = *ucontrol->value.integer.value;
775	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
776						    AC_VERB_GET_DIGI_CONVERT_1,
777						    0x00);
778
779	/* Set/unset the masked control bit(s) as needed */
780	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
781	if (val==0)
782		ctrl_data &= ~mask;
783	else
784		ctrl_data |= mask;
785	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
786				  ctrl_data);
787
788	return change;
789}
790#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
791	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
792	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
793	  .info = alc_spdif_ctrl_info, \
794	  .get = alc_spdif_ctrl_get, \
795	  .put = alc_spdif_ctrl_put, \
796	  .private_value = nid | (mask<<16) }
797#endif   /* CONFIG_SND_DEBUG */
798
799/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
800 * Again, this is only used in the ALC26x test models to help identify when
801 * the EAPD line must be asserted for features to work.
802 */
803#ifdef CONFIG_SND_DEBUG
804#define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info
805
806static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
807			      struct snd_ctl_elem_value *ucontrol)
808{
809	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
810	hda_nid_t nid = kcontrol->private_value & 0xffff;
811	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
812	long *valp = ucontrol->value.integer.value;
813	unsigned int val = snd_hda_codec_read(codec, nid, 0,
814					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);
815
816	*valp = (val & mask) != 0;
817	return 0;
818}
819
820static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
821			      struct snd_ctl_elem_value *ucontrol)
822{
823	int change;
824	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
825	hda_nid_t nid = kcontrol->private_value & 0xffff;
826	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
827	long val = *ucontrol->value.integer.value;
828	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
829						    AC_VERB_GET_EAPD_BTLENABLE,
830						    0x00);
831
832	/* Set/unset the masked control bit(s) as needed */
833	change = (!val ? 0 : mask) != (ctrl_data & mask);
834	if (!val)
835		ctrl_data &= ~mask;
836	else
837		ctrl_data |= mask;
838	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
839				  ctrl_data);
840
841	return change;
842}
843
844#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
845	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
846	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
847	  .info = alc_eapd_ctrl_info, \
848	  .get = alc_eapd_ctrl_get, \
849	  .put = alc_eapd_ctrl_put, \
850	  .private_value = nid | (mask<<16) }
851#endif   /* CONFIG_SND_DEBUG */
852
853/*
854 * set up the input pin config (depending on the given auto-pin type)
855 */
856static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
857			      int auto_pin_type)
858{
859	unsigned int val = PIN_IN;
860
861	if (auto_pin_type == AUTO_PIN_MIC) {
862		unsigned int pincap;
863		unsigned int oldval;
864		oldval = snd_hda_codec_read(codec, nid, 0,
865					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
866		pincap = snd_hda_query_pin_caps(codec, nid);
867		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
868		/* if the default pin setup is vref50, we give it priority */
869		if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
870			val = PIN_VREF80;
871		else if (pincap & AC_PINCAP_VREF_50)
872			val = PIN_VREF50;
873		else if (pincap & AC_PINCAP_VREF_100)
874			val = PIN_VREF100;
875		else if (pincap & AC_PINCAP_VREF_GRD)
876			val = PIN_VREFGRD;
877	}
878	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
879}
880
881static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
882{
883	struct alc_spec *spec = codec->spec;
884	struct auto_pin_cfg *cfg = &spec->autocfg;
885
886	if (!cfg->line_outs) {
887		while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
888		       cfg->line_out_pins[cfg->line_outs])
889			cfg->line_outs++;
890	}
891	if (!cfg->speaker_outs) {
892		while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
893		       cfg->speaker_pins[cfg->speaker_outs])
894			cfg->speaker_outs++;
895	}
896	if (!cfg->hp_outs) {
897		while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
898		       cfg->hp_pins[cfg->hp_outs])
899			cfg->hp_outs++;
900	}
901}
902
903/*
904 */
905static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
906{
907	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
908		return;
909	spec->mixers[spec->num_mixers++] = mix;
910}
911
912static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
913{
914	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
915		return;
916	spec->init_verbs[spec->num_init_verbs++] = verb;
917}
918
919/*
920 * set up from the preset table
921 */
922static void setup_preset(struct hda_codec *codec,
923			 const struct alc_config_preset *preset)
924{
925	struct alc_spec *spec = codec->spec;
926	int i;
927
928	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
929		add_mixer(spec, preset->mixers[i]);
930	spec->cap_mixer = preset->cap_mixer;
931	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
932	     i++)
933		add_verb(spec, preset->init_verbs[i]);
934
935	spec->channel_mode = preset->channel_mode;
936	spec->num_channel_mode = preset->num_channel_mode;
937	spec->need_dac_fix = preset->need_dac_fix;
938	spec->const_channel_count = preset->const_channel_count;
939
940	if (preset->const_channel_count)
941		spec->multiout.max_channels = preset->const_channel_count;
942	else
943		spec->multiout.max_channels = spec->channel_mode[0].channels;
944	spec->ext_channel_count = spec->channel_mode[0].channels;
945
946	spec->multiout.num_dacs = preset->num_dacs;
947	spec->multiout.dac_nids = preset->dac_nids;
948	spec->multiout.dig_out_nid = preset->dig_out_nid;
949	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
950	spec->multiout.hp_nid = preset->hp_nid;
951
952	spec->num_mux_defs = preset->num_mux_defs;
953	if (!spec->num_mux_defs)
954		spec->num_mux_defs = 1;
955	spec->input_mux = preset->input_mux;
956
957	spec->num_adc_nids = preset->num_adc_nids;
958	spec->adc_nids = preset->adc_nids;
959	spec->capsrc_nids = preset->capsrc_nids;
960	spec->dig_in_nid = preset->dig_in_nid;
961
962	spec->unsol_event = preset->unsol_event;
963	spec->init_hook = preset->init_hook;
964#ifdef CONFIG_SND_HDA_POWER_SAVE
965	spec->power_hook = preset->power_hook;
966	spec->loopback.amplist = preset->loopbacks;
967#endif
968
969	if (preset->setup)
970		preset->setup(codec);
971
972	alc_fixup_autocfg_pin_nums(codec);
973}
974
975/* Enable GPIO mask and set output */
976static struct hda_verb alc_gpio1_init_verbs[] = {
977	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
978	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
979	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
980	{ }
981};
982
983static struct hda_verb alc_gpio2_init_verbs[] = {
984	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
985	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
986	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
987	{ }
988};
989
990static struct hda_verb alc_gpio3_init_verbs[] = {
991	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
992	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
993	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
994	{ }
995};
996
997/*
998 * Fix hardware PLL issue
999 * On some codecs, the analog PLL gating control must be off while
1000 * the default value is 1.
1001 */
1002static void alc_fix_pll(struct hda_codec *codec)
1003{
1004	struct alc_spec *spec = codec->spec;
1005	unsigned int val;
1006
1007	if (!spec->pll_nid)
1008		return;
1009	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1010			    spec->pll_coef_idx);
1011	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1012				 AC_VERB_GET_PROC_COEF, 0);
1013	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1014			    spec->pll_coef_idx);
1015	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1016			    val & ~(1 << spec->pll_coef_bit));
1017}
1018
1019static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1020			     unsigned int coef_idx, unsigned int coef_bit)
1021{
1022	struct alc_spec *spec = codec->spec;
1023	spec->pll_nid = nid;
1024	spec->pll_coef_idx = coef_idx;
1025	spec->pll_coef_bit = coef_bit;
1026	alc_fix_pll(codec);
1027}
1028
1029#ifdef CONFIG_SND_HDA_INPUT_JACK
1030static void alc_free_jack_priv(struct snd_jack *jack)
1031{
1032	struct alc_jack *jacks = jack->private_data;
1033	jacks->nid = 0;
1034	jacks->jack = NULL;
1035}
1036
1037static int alc_add_jack(struct hda_codec *codec,
1038		hda_nid_t nid, int type)
1039{
1040	struct alc_spec *spec;
1041	struct alc_jack *jack;
1042	const char *name;
1043	int err;
1044
1045	spec = codec->spec;
1046	snd_array_init(&spec->jacks, sizeof(*jack), 32);
1047	jack = snd_array_new(&spec->jacks);
1048	if (!jack)
1049		return -ENOMEM;
1050
1051	jack->nid = nid;
1052	jack->type = type;
1053	name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ;
1054
1055	err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
1056	if (err < 0)
1057		return err;
1058	jack->jack->private_data = jack;
1059	jack->jack->private_free = alc_free_jack_priv;
1060	return 0;
1061}
1062
1063static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1064{
1065	struct alc_spec *spec = codec->spec;
1066	struct alc_jack *jacks = spec->jacks.list;
1067
1068	if (jacks) {
1069		int i;
1070		for (i = 0; i < spec->jacks.used; i++) {
1071			if (jacks->nid == nid) {
1072				unsigned int present;
1073				present = snd_hda_jack_detect(codec, nid);
1074
1075				present = (present) ? jacks->type : 0;
1076
1077				snd_jack_report(jacks->jack, present);
1078			}
1079			jacks++;
1080		}
1081	}
1082}
1083
1084static int alc_init_jacks(struct hda_codec *codec)
1085{
1086	struct alc_spec *spec = codec->spec;
1087	int err;
1088	unsigned int hp_nid = spec->autocfg.hp_pins[0];
1089	unsigned int mic_nid = spec->ext_mic.pin;
1090
1091	if (hp_nid) {
1092		err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE);
1093		if (err < 0)
1094			return err;
1095		alc_report_jack(codec, hp_nid);
1096	}
1097
1098	if (mic_nid) {
1099		err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE);
1100		if (err < 0)
1101			return err;
1102		alc_report_jack(codec, mic_nid);
1103	}
1104
1105	return 0;
1106}
1107#else
1108static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid)
1109{
1110}
1111
1112static inline int alc_init_jacks(struct hda_codec *codec)
1113{
1114	return 0;
1115}
1116#endif
1117
1118static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1119{
1120	struct alc_spec *spec = codec->spec;
1121	unsigned int mute;
1122	hda_nid_t nid;
1123	int i;
1124
1125	spec->jack_present = 0;
1126	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1127		nid = spec->autocfg.hp_pins[i];
1128		if (!nid)
1129			break;
1130		if (snd_hda_jack_detect(codec, nid)) {
1131			spec->jack_present = 1;
1132			break;
1133		}
1134		alc_report_jack(codec, spec->autocfg.hp_pins[i]);
1135	}
1136
1137	mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1138	/* Toggle internal speakers muting */
1139	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1140		nid = spec->autocfg.speaker_pins[i];
1141		if (!nid)
1142			break;
1143		if (pinctl) {
1144			snd_hda_codec_write(codec, nid, 0,
1145				    AC_VERB_SET_PIN_WIDGET_CONTROL,
1146				    spec->jack_present ? 0 : PIN_OUT);
1147		} else {
1148			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1149					 HDA_AMP_MUTE, mute);
1150		}
1151	}
1152}
1153
1154static void alc_automute_pin(struct hda_codec *codec)
1155{
1156	alc_automute_speaker(codec, 1);
1157}
1158
1159static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1160				hda_nid_t nid)
1161{
1162	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1163	int i, nums;
1164
1165	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1166	for (i = 0; i < nums; i++)
1167		if (conn[i] == nid)
1168			return i;
1169	return -1;
1170}
1171
1172/* switch the current ADC according to the jack state */
1173static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1174{
1175	struct alc_spec *spec = codec->spec;
1176	unsigned int present;
1177	hda_nid_t new_adc;
1178
1179	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1180	if (present)
1181		spec->cur_adc_idx = 1;
1182	else
1183		spec->cur_adc_idx = 0;
1184	new_adc = spec->adc_nids[spec->cur_adc_idx];
1185	if (spec->cur_adc && spec->cur_adc != new_adc) {
1186		/* stream is running, let's swap the current ADC */
1187		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1188		spec->cur_adc = new_adc;
1189		snd_hda_codec_setup_stream(codec, new_adc,
1190					   spec->cur_adc_stream_tag, 0,
1191					   spec->cur_adc_format);
1192	}
1193}
1194
1195static void alc_mic_automute(struct hda_codec *codec)
1196{
1197	struct alc_spec *spec = codec->spec;
1198	struct alc_mic_route *dead, *alive;
1199	unsigned int present, type;
1200	hda_nid_t cap_nid;
1201
1202	if (!spec->auto_mic)
1203		return;
1204	if (!spec->int_mic.pin || !spec->ext_mic.pin)
1205		return;
1206	if (snd_BUG_ON(!spec->adc_nids))
1207		return;
1208
1209	if (spec->dual_adc_switch) {
1210		alc_dual_mic_adc_auto_switch(codec);
1211		return;
1212	}
1213
1214	cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1215
1216	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1217	if (present) {
1218		alive = &spec->ext_mic;
1219		dead = &spec->int_mic;
1220	} else {
1221		alive = &spec->int_mic;
1222		dead = &spec->ext_mic;
1223	}
1224
1225	type = get_wcaps_type(get_wcaps(codec, cap_nid));
1226	if (type == AC_WID_AUD_MIX) {
1227		/* Matrix-mixer style (e.g. ALC882) */
1228		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1229					 alive->mux_idx,
1230					 HDA_AMP_MUTE, 0);
1231		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1232					 dead->mux_idx,
1233					 HDA_AMP_MUTE, HDA_AMP_MUTE);
1234	} else {
1235		/* MUX style (e.g. ALC880) */
1236		snd_hda_codec_write_cache(codec, cap_nid, 0,
1237					  AC_VERB_SET_CONNECT_SEL,
1238					  alive->mux_idx);
1239	}
1240	alc_report_jack(codec, spec->ext_mic.pin);
1241
1242	/* FIXME: analog mixer */
1243}
1244
1245/* unsolicited event for HP jack sensing */
1246static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1247{
1248	if (codec->vendor_id == 0x10ec0880)
1249		res >>= 28;
1250	else
1251		res >>= 26;
1252	switch (res) {
1253	case ALC880_HP_EVENT:
1254		alc_automute_pin(codec);
1255		break;
1256	case ALC880_MIC_EVENT:
1257		alc_mic_automute(codec);
1258		break;
1259	}
1260}
1261
1262static void alc_inithook(struct hda_codec *codec)
1263{
1264	alc_automute_pin(codec);
1265	alc_mic_automute(codec);
1266}
1267
1268/* additional initialization for ALC888 variants */
1269static void alc888_coef_init(struct hda_codec *codec)
1270{
1271	unsigned int tmp;
1272
1273	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1274	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1275	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1276	if ((tmp & 0xf0) == 0x20)
1277		/* alc888S-VC */
1278		snd_hda_codec_read(codec, 0x20, 0,
1279				   AC_VERB_SET_PROC_COEF, 0x830);
1280	 else
1281		 /* alc888-VB */
1282		 snd_hda_codec_read(codec, 0x20, 0,
1283				    AC_VERB_SET_PROC_COEF, 0x3030);
1284}
1285
1286static void alc889_coef_init(struct hda_codec *codec)
1287{
1288	unsigned int tmp;
1289
1290	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1291	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1292	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1293	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1294}
1295
1296/* turn on/off EAPD control (only if available) */
1297static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1298{
1299	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1300		return;
1301	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1302		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1303				    on ? 2 : 0);
1304}
1305
1306static void alc_auto_init_amp(struct hda_codec *codec, int type)
1307{
1308	unsigned int tmp;
1309
1310	switch (type) {
1311	case ALC_INIT_GPIO1:
1312		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1313		break;
1314	case ALC_INIT_GPIO2:
1315		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1316		break;
1317	case ALC_INIT_GPIO3:
1318		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1319		break;
1320	case ALC_INIT_DEFAULT:
1321		switch (codec->vendor_id) {
1322		case 0x10ec0260:
1323			set_eapd(codec, 0x0f, 1);
1324			set_eapd(codec, 0x10, 1);
1325			break;
1326		case 0x10ec0262:
1327		case 0x10ec0267:
1328		case 0x10ec0268:
1329		case 0x10ec0269:
1330		case 0x10ec0270:
1331		case 0x10ec0272:
1332		case 0x10ec0660:
1333		case 0x10ec0662:
1334		case 0x10ec0663:
1335		case 0x10ec0862:
1336		case 0x10ec0889:
1337			set_eapd(codec, 0x14, 1);
1338			set_eapd(codec, 0x15, 1);
1339			break;
1340		}
1341		switch (codec->vendor_id) {
1342		case 0x10ec0260:
1343			snd_hda_codec_write(codec, 0x1a, 0,
1344					    AC_VERB_SET_COEF_INDEX, 7);
1345			tmp = snd_hda_codec_read(codec, 0x1a, 0,
1346						 AC_VERB_GET_PROC_COEF, 0);
1347			snd_hda_codec_write(codec, 0x1a, 0,
1348					    AC_VERB_SET_COEF_INDEX, 7);
1349			snd_hda_codec_write(codec, 0x1a, 0,
1350					    AC_VERB_SET_PROC_COEF,
1351					    tmp | 0x2010);
1352			break;
1353		case 0x10ec0262:
1354		case 0x10ec0880:
1355		case 0x10ec0882:
1356		case 0x10ec0883:
1357		case 0x10ec0885:
1358		case 0x10ec0887:
1359		case 0x10ec0889:
1360			alc889_coef_init(codec);
1361			break;
1362		case 0x10ec0888:
1363			alc888_coef_init(codec);
1364			break;
1365#if 0 /* XXX: This may cause the silent output on speaker on some machines */
1366		case 0x10ec0267:
1367		case 0x10ec0268:
1368			snd_hda_codec_write(codec, 0x20, 0,
1369					    AC_VERB_SET_COEF_INDEX, 7);
1370			tmp = snd_hda_codec_read(codec, 0x20, 0,
1371						 AC_VERB_GET_PROC_COEF, 0);
1372			snd_hda_codec_write(codec, 0x20, 0,
1373					    AC_VERB_SET_COEF_INDEX, 7);
1374			snd_hda_codec_write(codec, 0x20, 0,
1375					    AC_VERB_SET_PROC_COEF,
1376					    tmp | 0x3000);
1377			break;
1378#endif /* XXX */
1379		}
1380		break;
1381	}
1382}
1383
1384static void alc_init_auto_hp(struct hda_codec *codec)
1385{
1386	struct alc_spec *spec = codec->spec;
1387	struct auto_pin_cfg *cfg = &spec->autocfg;
1388	int i;
1389
1390	if (!cfg->hp_pins[0]) {
1391		if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1392			return;
1393	}
1394
1395	if (!cfg->speaker_pins[0]) {
1396		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1397			return;
1398		memcpy(cfg->speaker_pins, cfg->line_out_pins,
1399		       sizeof(cfg->speaker_pins));
1400		cfg->speaker_outs = cfg->line_outs;
1401	}
1402
1403	if (!cfg->hp_pins[0]) {
1404		memcpy(cfg->hp_pins, cfg->line_out_pins,
1405		       sizeof(cfg->hp_pins));
1406		cfg->hp_outs = cfg->line_outs;
1407	}
1408
1409	for (i = 0; i < cfg->hp_outs; i++) {
1410		snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1411			    cfg->hp_pins[i]);
1412		snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1413				  AC_VERB_SET_UNSOLICITED_ENABLE,
1414				  AC_USRSP_EN | ALC880_HP_EVENT);
1415	}
1416	spec->unsol_event = alc_sku_unsol_event;
1417}
1418
1419static void alc_init_auto_mic(struct hda_codec *codec)
1420{
1421	struct alc_spec *spec = codec->spec;
1422	struct auto_pin_cfg *cfg = &spec->autocfg;
1423	hda_nid_t fixed, ext;
1424	int i;
1425
1426	/* there must be only two mic inputs exclusively */
1427	for (i = 0; i < cfg->num_inputs; i++)
1428		if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1429			return;
1430
1431	fixed = ext = 0;
1432	for (i = 0; i < cfg->num_inputs; i++) {
1433		hda_nid_t nid = cfg->inputs[i].pin;
1434		unsigned int defcfg;
1435		defcfg = snd_hda_codec_get_pincfg(codec, nid);
1436		switch (snd_hda_get_input_pin_attr(defcfg)) {
1437		case INPUT_PIN_ATTR_INT:
1438			if (fixed)
1439				return; /* already occupied */
1440			fixed = nid;
1441			break;
1442		case INPUT_PIN_ATTR_UNUSED:
1443			return; /* invalid entry */
1444		default:
1445			if (ext)
1446				return; /* already occupied */
1447			ext = nid;
1448			break;
1449		}
1450	}
1451	if (!ext || !fixed)
1452		return;
1453	if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1454		return; /* no unsol support */
1455	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1456		    ext, fixed);
1457	spec->ext_mic.pin = ext;
1458	spec->int_mic.pin = fixed;
1459	spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1460	spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1461	spec->auto_mic = 1;
1462	snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1463				  AC_VERB_SET_UNSOLICITED_ENABLE,
1464				  AC_USRSP_EN | ALC880_MIC_EVENT);
1465	spec->unsol_event = alc_sku_unsol_event;
1466}
1467
1468/* Could be any non-zero and even value. When used as fixup, tells
1469 * the driver to ignore any present sku defines.
1470 */
1471#define ALC_FIXUP_SKU_IGNORE (2)
1472
1473static int alc_auto_parse_customize_define(struct hda_codec *codec)
1474{
1475	unsigned int ass, tmp, i;
1476	unsigned nid = 0;
1477	struct alc_spec *spec = codec->spec;
1478
1479	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1480
1481	if (spec->cdefine.fixup) {
1482		ass = spec->cdefine.sku_cfg;
1483		if (ass == ALC_FIXUP_SKU_IGNORE)
1484			return -1;
1485		goto do_sku;
1486	}
1487
1488	ass = codec->subsystem_id & 0xffff;
1489	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1490		goto do_sku;
1491
1492	nid = 0x1d;
1493	if (codec->vendor_id == 0x10ec0260)
1494		nid = 0x17;
1495	ass = snd_hda_codec_get_pincfg(codec, nid);
1496
1497	if (!(ass & 1)) {
1498		printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1499		       codec->chip_name, ass);
1500		return -1;
1501	}
1502
1503	/* check sum */
1504	tmp = 0;
1505	for (i = 1; i < 16; i++) {
1506		if ((ass >> i) & 1)
1507			tmp++;
1508	}
1509	if (((ass >> 16) & 0xf) != tmp)
1510		return -1;
1511
1512	spec->cdefine.port_connectivity = ass >> 30;
1513	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1514	spec->cdefine.check_sum = (ass >> 16) & 0xf;
1515	spec->cdefine.customization = ass >> 8;
1516do_sku:
1517	spec->cdefine.sku_cfg = ass;
1518	spec->cdefine.external_amp = (ass & 0x38) >> 3;
1519	spec->cdefine.platform_type = (ass & 0x4) >> 2;
1520	spec->cdefine.swap = (ass & 0x2) >> 1;
1521	spec->cdefine.override = ass & 0x1;
1522
1523	snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1524		   nid, spec->cdefine.sku_cfg);
1525	snd_printd("SKU: port_connectivity=0x%x\n",
1526		   spec->cdefine.port_connectivity);
1527	snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1528	snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1529	snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1530	snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1531	snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1532	snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1533	snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1534
1535	return 0;
1536}
1537
1538/* check subsystem ID and set up device-specific initialization;
1539 * return 1 if initialized, 0 if invalid SSID
1540 */
1541/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1542 *	31 ~ 16 :	Manufacture ID
1543 *	15 ~ 8	:	SKU ID
1544 *	7  ~ 0	:	Assembly ID
1545 *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1546 */
1547static int alc_subsystem_id(struct hda_codec *codec,
1548			    hda_nid_t porta, hda_nid_t porte,
1549			    hda_nid_t portd, hda_nid_t porti)
1550{
1551	unsigned int ass, tmp, i;
1552	unsigned nid;
1553	struct alc_spec *spec = codec->spec;
1554
1555	if (spec->cdefine.fixup) {
1556		ass = spec->cdefine.sku_cfg;
1557		if (ass == ALC_FIXUP_SKU_IGNORE)
1558			return 0;
1559		goto do_sku;
1560	}
1561
1562	ass = codec->subsystem_id & 0xffff;
1563	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1564		goto do_sku;
1565
1566	/* invalid SSID, check the special NID pin defcfg instead */
1567	/*
1568	 * 31~30	: port connectivity
1569	 * 29~21	: reserve
1570	 * 20		: PCBEEP input
1571	 * 19~16	: Check sum (15:1)
1572	 * 15~1		: Custom
1573	 * 0		: override
1574	*/
1575	nid = 0x1d;
1576	if (codec->vendor_id == 0x10ec0260)
1577		nid = 0x17;
1578	ass = snd_hda_codec_get_pincfg(codec, nid);
1579	snd_printd("realtek: No valid SSID, "
1580		   "checking pincfg 0x%08x for NID 0x%x\n",
1581		   ass, nid);
1582	if (!(ass & 1))
1583		return 0;
1584	if ((ass >> 30) != 1)	/* no physical connection */
1585		return 0;
1586
1587	/* check sum */
1588	tmp = 0;
1589	for (i = 1; i < 16; i++) {
1590		if ((ass >> i) & 1)
1591			tmp++;
1592	}
1593	if (((ass >> 16) & 0xf) != tmp)
1594		return 0;
1595do_sku:
1596	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1597		   ass & 0xffff, codec->vendor_id);
1598	/*
1599	 * 0 : override
1600	 * 1 :	Swap Jack
1601	 * 2 : 0 --> Desktop, 1 --> Laptop
1602	 * 3~5 : External Amplifier control
1603	 * 7~6 : Reserved
1604	*/
1605	tmp = (ass & 0x38) >> 3;	/* external Amp control */
1606	switch (tmp) {
1607	case 1:
1608		spec->init_amp = ALC_INIT_GPIO1;
1609		break;
1610	case 3:
1611		spec->init_amp = ALC_INIT_GPIO2;
1612		break;
1613	case 7:
1614		spec->init_amp = ALC_INIT_GPIO3;
1615		break;
1616	case 5:
1617	default:
1618		spec->init_amp = ALC_INIT_DEFAULT;
1619		break;
1620	}
1621
1622	/* is laptop or Desktop and enable the function "Mute internal speaker
1623	 * when the external headphone out jack is plugged"
1624	 */
1625	if (!(ass & 0x8000))
1626		return 1;
1627	/*
1628	 * 10~8 : Jack location
1629	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1630	 * 14~13: Resvered
1631	 * 15   : 1 --> enable the function "Mute internal speaker
1632	 *	        when the external headphone out jack is plugged"
1633	 */
1634	if (!spec->autocfg.hp_pins[0]) {
1635		hda_nid_t nid;
1636		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
1637		if (tmp == 0)
1638			nid = porta;
1639		else if (tmp == 1)
1640			nid = porte;
1641		else if (tmp == 2)
1642			nid = portd;
1643		else if (tmp == 3)
1644			nid = porti;
1645		else
1646			return 1;
1647		for (i = 0; i < spec->autocfg.line_outs; i++)
1648			if (spec->autocfg.line_out_pins[i] == nid)
1649				return 1;
1650		spec->autocfg.hp_pins[0] = nid;
1651	}
1652
1653	alc_init_auto_hp(codec);
1654	alc_init_auto_mic(codec);
1655	return 1;
1656}
1657
1658static void alc_ssid_check(struct hda_codec *codec,
1659			   hda_nid_t porta, hda_nid_t porte,
1660			   hda_nid_t portd, hda_nid_t porti)
1661{
1662	if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1663		struct alc_spec *spec = codec->spec;
1664		snd_printd("realtek: "
1665			   "Enable default setup for auto mode as fallback\n");
1666		spec->init_amp = ALC_INIT_DEFAULT;
1667		alc_init_auto_hp(codec);
1668		alc_init_auto_mic(codec);
1669	}
1670}
1671
1672/*
1673 * Fix-up pin default configurations and add default verbs
1674 */
1675
1676struct alc_pincfg {
1677	hda_nid_t nid;
1678	u32 val;
1679};
1680
1681struct alc_fixup {
1682	unsigned int sku;
1683	const struct alc_pincfg *pins;
1684	const struct hda_verb *verbs;
1685};
1686
1687static void alc_pick_fixup(struct hda_codec *codec,
1688			   const struct snd_pci_quirk *quirk,
1689			   const struct alc_fixup *fix,
1690			   int pre_init)
1691{
1692	const struct alc_pincfg *cfg;
1693	struct alc_spec *spec;
1694
1695	quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1696	if (!quirk)
1697		return;
1698	fix += quirk->value;
1699	cfg = fix->pins;
1700	if (pre_init && fix->sku) {
1701#ifdef CONFIG_SND_DEBUG_VERBOSE
1702		snd_printdd(KERN_INFO "hda_codec: %s: Apply sku override for %s\n",
1703			    codec->chip_name, quirk->name);
1704#endif
1705		spec = codec->spec;
1706		spec->cdefine.sku_cfg = fix->sku;
1707		spec->cdefine.fixup = 1;
1708	}
1709	if (pre_init && cfg) {
1710#ifdef CONFIG_SND_DEBUG_VERBOSE
1711		snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
1712			    codec->chip_name, quirk->name);
1713#endif
1714		for (; cfg->nid; cfg++)
1715			snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1716	}
1717	if (!pre_init && fix->verbs) {
1718#ifdef CONFIG_SND_DEBUG_VERBOSE
1719		snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
1720			    codec->chip_name, quirk->name);
1721#endif
1722		add_verb(codec->spec, fix->verbs);
1723	}
1724}
1725
1726static int alc_read_coef_idx(struct hda_codec *codec,
1727			unsigned int coef_idx)
1728{
1729	unsigned int val;
1730	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1731		    		coef_idx);
1732	val = snd_hda_codec_read(codec, 0x20, 0,
1733			 	AC_VERB_GET_PROC_COEF, 0);
1734	return val;
1735}
1736
1737static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1738							unsigned int coef_val)
1739{
1740	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1741			    coef_idx);
1742	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1743			    coef_val);
1744}
1745
1746/* set right pin controls for digital I/O */
1747static void alc_auto_init_digital(struct hda_codec *codec)
1748{
1749	struct alc_spec *spec = codec->spec;
1750	int i;
1751	hda_nid_t pin;
1752
1753	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1754		pin = spec->autocfg.dig_out_pins[i];
1755		if (pin) {
1756			snd_hda_codec_write(codec, pin, 0,
1757					    AC_VERB_SET_PIN_WIDGET_CONTROL,
1758					    PIN_OUT);
1759		}
1760	}
1761	pin = spec->autocfg.dig_in_pin;
1762	if (pin)
1763		snd_hda_codec_write(codec, pin, 0,
1764				    AC_VERB_SET_PIN_WIDGET_CONTROL,
1765				    PIN_IN);
1766}
1767
1768/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1769static void alc_auto_parse_digital(struct hda_codec *codec)
1770{
1771	struct alc_spec *spec = codec->spec;
1772	int i, err;
1773	hda_nid_t dig_nid;
1774
1775	/* support multiple SPDIFs; the secondary is set up as a slave */
1776	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1777		err = snd_hda_get_connections(codec,
1778					      spec->autocfg.dig_out_pins[i],
1779					      &dig_nid, 1);
1780		if (err < 0)
1781			continue;
1782		if (!i) {
1783			spec->multiout.dig_out_nid = dig_nid;
1784			spec->dig_out_type = spec->autocfg.dig_out_type[0];
1785		} else {
1786			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1787			if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1788				break;
1789			spec->slave_dig_outs[i - 1] = dig_nid;
1790		}
1791	}
1792
1793	if (spec->autocfg.dig_in_pin) {
1794		dig_nid = codec->start_nid;
1795		for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1796			unsigned int wcaps = get_wcaps(codec, dig_nid);
1797			if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1798				continue;
1799			if (!(wcaps & AC_WCAP_DIGITAL))
1800				continue;
1801			if (!(wcaps & AC_WCAP_CONN_LIST))
1802				continue;
1803			err = get_connection_index(codec, dig_nid,
1804						   spec->autocfg.dig_in_pin);
1805			if (err >= 0) {
1806				spec->dig_in_nid = dig_nid;
1807				break;
1808			}
1809		}
1810	}
1811}
1812
1813/*
1814 * ALC888
1815 */
1816
1817/*
1818 * 2ch mode
1819 */
1820static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1821/* Mic-in jack as mic in */
1822	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1823	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1824/* Line-in jack as Line in */
1825	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1826	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1827/* Line-Out as Front */
1828	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1829	{ } /* end */
1830};
1831
1832/*
1833 * 4ch mode
1834 */
1835static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1836/* Mic-in jack as mic in */
1837	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1838	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1839/* Line-in jack as Surround */
1840	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1841	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1842/* Line-Out as Front */
1843	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1844	{ } /* end */
1845};
1846
1847/*
1848 * 6ch mode
1849 */
1850static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1851/* Mic-in jack as CLFE */
1852	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1853	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1854/* Line-in jack as Surround */
1855	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1856	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1857/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1858	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1859	{ } /* end */
1860};
1861
1862/*
1863 * 8ch mode
1864 */
1865static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1866/* Mic-in jack as CLFE */
1867	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1868	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1869/* Line-in jack as Surround */
1870	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1871	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1872/* Line-Out as Side */
1873	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1874	{ } /* end */
1875};
1876
1877static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1878	{ 2, alc888_4ST_ch2_intel_init },
1879	{ 4, alc888_4ST_ch4_intel_init },
1880	{ 6, alc888_4ST_ch6_intel_init },
1881	{ 8, alc888_4ST_ch8_intel_init },
1882};
1883
1884/*
1885 * ALC888 Fujitsu Siemens Amillo xa3530
1886 */
1887
1888static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1889/* Front Mic: set to PIN_IN (empty by default) */
1890	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1891/* Connect Internal HP to Front */
1892	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1893	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1894	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1895/* Connect Bass HP to Front */
1896	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1897	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1898	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1899/* Connect Line-Out side jack (SPDIF) to Side */
1900	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1901	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1902	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1903/* Connect Mic jack to CLFE */
1904	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1905	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1906	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1907/* Connect Line-in jack to Surround */
1908	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1909	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1910	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1911/* Connect HP out jack to Front */
1912	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1913	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1914	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1915/* Enable unsolicited event for HP jack and Line-out jack */
1916	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1917	{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1918	{}
1919};
1920
1921static void alc_automute_amp(struct hda_codec *codec)
1922{
1923	alc_automute_speaker(codec, 0);
1924}
1925
1926static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1927					 unsigned int res)
1928{
1929	if (codec->vendor_id == 0x10ec0880)
1930		res >>= 28;
1931	else
1932		res >>= 26;
1933	if (res == ALC880_HP_EVENT)
1934		alc_automute_amp(codec);
1935}
1936
1937static void alc889_automute_setup(struct hda_codec *codec)
1938{
1939	struct alc_spec *spec = codec->spec;
1940
1941	spec->autocfg.hp_pins[0] = 0x15;
1942	spec->autocfg.speaker_pins[0] = 0x14;
1943	spec->autocfg.speaker_pins[1] = 0x16;
1944	spec->autocfg.speaker_pins[2] = 0x17;
1945	spec->autocfg.speaker_pins[3] = 0x19;
1946	spec->autocfg.speaker_pins[4] = 0x1a;
1947}
1948
1949static void alc889_intel_init_hook(struct hda_codec *codec)
1950{
1951	alc889_coef_init(codec);
1952	alc_automute_amp(codec);
1953}
1954
1955static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1956{
1957	struct alc_spec *spec = codec->spec;
1958
1959	spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1960	spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1961	spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1962	spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1963}
1964
1965/*
1966 * ALC888 Acer Aspire 4930G model
1967 */
1968
1969static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1970/* Front Mic: set to PIN_IN (empty by default) */
1971	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1972/* Unselect Front Mic by default in input mixer 3 */
1973	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1974/* Enable unsolicited event for HP jack */
1975	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1976/* Connect Internal HP to front */
1977	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1978	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1979	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1980/* Connect HP out to front */
1981	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1982	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1983	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1984	{ }
1985};
1986
1987/*
1988 * ALC888 Acer Aspire 6530G model
1989 */
1990
1991static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1992/* Route to built-in subwoofer as well as speakers */
1993	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1994	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1995	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1996	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1997/* Bias voltage on for external mic port */
1998	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1999/* Front Mic: set to PIN_IN (empty by default) */
2000	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2001/* Unselect Front Mic by default in input mixer 3 */
2002	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2003/* Enable unsolicited event for HP jack */
2004	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2005/* Enable speaker output */
2006	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2007	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2008	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2009/* Enable headphone output */
2010	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2011	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2012	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2013	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2014	{ }
2015};
2016
2017/*
2018 *ALC888 Acer Aspire 7730G model
2019 */
2020
2021static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2022/* Bias voltage on for external mic port */
2023	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2024/* Front Mic: set to PIN_IN (empty by default) */
2025	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2026/* Unselect Front Mic by default in input mixer 3 */
2027	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2028/* Enable unsolicited event for HP jack */
2029	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2030/* Enable speaker output */
2031	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2032	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2033	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2034/* Enable headphone output */
2035	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2036	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2037	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2038	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2039/*Enable internal subwoofer */
2040	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2041	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2042	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2043	{0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2044	{ }
2045};
2046
2047/*
2048 * ALC889 Acer Aspire 8930G model
2049 */
2050
2051static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2052/* Front Mic: set to PIN_IN (empty by default) */
2053	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2054/* Unselect Front Mic by default in input mixer 3 */
2055	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2056/* Enable unsolicited event for HP jack */
2057	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2058/* Connect Internal Front to Front */
2059	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2060	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2061	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2062/* Connect Internal Rear to Rear */
2063	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2064	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2065	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2066/* Connect Internal CLFE to CLFE */
2067	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2068	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2069	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2070/* Connect HP out to Front */
2071	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2072	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2073	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2074/* Enable all DACs */
2075/*  DAC DISABLE/MUTE 1? */
2076/*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2077	{0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2078	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2079/*  DAC DISABLE/MUTE 2? */
2080/*  some bit here disables the other DACs. Init=0x4900 */
2081	{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2082	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2083/* DMIC fix
2084 * This laptop has a stereo digital microphone. The mics are only 1cm apart
2085 * which makes the stereo useless. However, either the mic or the ALC889
2086 * makes the signal become a difference/sum signal instead of standard
2087 * stereo, which is annoying. So instead we flip this bit which makes the
2088 * codec replicate the sum signal to both channels, turning it into a
2089 * normal mono mic.
2090 */
2091/*  DMIC_CONTROL? Init value = 0x0001 */
2092	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2093	{0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2094	{ }
2095};
2096
2097static struct hda_input_mux alc888_2_capture_sources[2] = {
2098	/* Front mic only available on one ADC */
2099	{
2100		.num_items = 4,
2101		.items = {
2102			{ "Mic", 0x0 },
2103			{ "Line", 0x2 },
2104			{ "CD", 0x4 },
2105			{ "Front Mic", 0xb },
2106		},
2107	},
2108	{
2109		.num_items = 3,
2110		.items = {
2111			{ "Mic", 0x0 },
2112			{ "Line", 0x2 },
2113			{ "CD", 0x4 },
2114		},
2115	}
2116};
2117
2118static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2119	/* Interal mic only available on one ADC */
2120	{
2121		.num_items = 5,
2122		.items = {
2123			{ "Ext Mic", 0x0 },
2124			{ "Line In", 0x2 },
2125			{ "CD", 0x4 },
2126			{ "Input Mix", 0xa },
2127			{ "Int Mic", 0xb },
2128		},
2129	},
2130	{
2131		.num_items = 4,
2132		.items = {
2133			{ "Ext Mic", 0x0 },
2134			{ "Line In", 0x2 },
2135			{ "CD", 0x4 },
2136			{ "Input Mix", 0xa },
2137		},
2138	}
2139};
2140
2141static struct hda_input_mux alc889_capture_sources[3] = {
2142	/* Digital mic only available on first "ADC" */
2143	{
2144		.num_items = 5,
2145		.items = {
2146			{ "Mic", 0x0 },
2147			{ "Line", 0x2 },
2148			{ "CD", 0x4 },
2149			{ "Front Mic", 0xb },
2150			{ "Input Mix", 0xa },
2151		},
2152	},
2153	{
2154		.num_items = 4,
2155		.items = {
2156			{ "Mic", 0x0 },
2157			{ "Line", 0x2 },
2158			{ "CD", 0x4 },
2159			{ "Input Mix", 0xa },
2160		},
2161	},
2162	{
2163		.num_items = 4,
2164		.items = {
2165			{ "Mic", 0x0 },
2166			{ "Line", 0x2 },
2167			{ "CD", 0x4 },
2168			{ "Input Mix", 0xa },
2169		},
2170	}
2171};
2172
2173static struct snd_kcontrol_new alc888_base_mixer[] = {
2174	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2175	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2176	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2177	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2178	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2179		HDA_OUTPUT),
2180	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2181	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2182	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2183	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2184	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2185	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2186	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2187	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2188	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2189	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2190	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2191	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2192	{ } /* end */
2193};
2194
2195static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2196	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2197	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2198	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2199	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2200	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2201		HDA_OUTPUT),
2202	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2203	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2204	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2205	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2206	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2207	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2208	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2209	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2210	{ } /* end */
2211};
2212
2213
2214static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2215{
2216	struct alc_spec *spec = codec->spec;
2217
2218	spec->autocfg.hp_pins[0] = 0x15;
2219	spec->autocfg.speaker_pins[0] = 0x14;
2220	spec->autocfg.speaker_pins[1] = 0x16;
2221	spec->autocfg.speaker_pins[2] = 0x17;
2222}
2223
2224static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2225{
2226	struct alc_spec *spec = codec->spec;
2227
2228	spec->autocfg.hp_pins[0] = 0x15;
2229	spec->autocfg.speaker_pins[0] = 0x14;
2230	spec->autocfg.speaker_pins[1] = 0x16;
2231	spec->autocfg.speaker_pins[2] = 0x17;
2232}
2233
2234static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2235{
2236	struct alc_spec *spec = codec->spec;
2237
2238	spec->autocfg.hp_pins[0] = 0x15;
2239	spec->autocfg.speaker_pins[0] = 0x14;
2240	spec->autocfg.speaker_pins[1] = 0x16;
2241	spec->autocfg.speaker_pins[2] = 0x17;
2242}
2243
2244static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2245{
2246	struct alc_spec *spec = codec->spec;
2247
2248	spec->autocfg.hp_pins[0] = 0x15;
2249	spec->autocfg.speaker_pins[0] = 0x14;
2250	spec->autocfg.speaker_pins[1] = 0x16;
2251	spec->autocfg.speaker_pins[2] = 0x1b;
2252}
2253
2254/*
2255 * ALC880 3-stack model
2256 *
2257 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2258 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2259 *                 F-Mic = 0x1b, HP = 0x19
2260 */
2261
2262static hda_nid_t alc880_dac_nids[4] = {
2263	/* front, rear, clfe, rear_surr */
2264	0x02, 0x05, 0x04, 0x03
2265};
2266
2267static hda_nid_t alc880_adc_nids[3] = {
2268	/* ADC0-2 */
2269	0x07, 0x08, 0x09,
2270};
2271
2272/* The datasheet says the node 0x07 is connected from inputs,
2273 * but it shows zero connection in the real implementation on some devices.
2274 * Note: this is a 915GAV bug, fixed on 915GLV
2275 */
2276static hda_nid_t alc880_adc_nids_alt[2] = {
2277	/* ADC1-2 */
2278	0x08, 0x09,
2279};
2280
2281#define ALC880_DIGOUT_NID	0x06
2282#define ALC880_DIGIN_NID	0x0a
2283
2284static struct hda_input_mux alc880_capture_source = {
2285	.num_items = 4,
2286	.items = {
2287		{ "Mic", 0x0 },
2288		{ "Front Mic", 0x3 },
2289		{ "Line", 0x2 },
2290		{ "CD", 0x4 },
2291	},
2292};
2293
2294/* channel source setting (2/6 channel selection for 3-stack) */
2295/* 2ch mode */
2296static struct hda_verb alc880_threestack_ch2_init[] = {
2297	/* set line-in to input, mute it */
2298	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2299	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2300	/* set mic-in to input vref 80%, mute it */
2301	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2302	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2303	{ } /* end */
2304};
2305
2306/* 6ch mode */
2307static struct hda_verb alc880_threestack_ch6_init[] = {
2308	/* set line-in to output, unmute it */
2309	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2310	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2311	/* set mic-in to output, unmute it */
2312	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2313	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2314	{ } /* end */
2315};
2316
2317static struct hda_channel_mode alc880_threestack_modes[2] = {
2318	{ 2, alc880_threestack_ch2_init },
2319	{ 6, alc880_threestack_ch6_init },
2320};
2321
2322static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2323	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2324	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2325	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2326	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2327	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2328	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2329	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2330	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2331	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2332	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2333	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2334	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2335	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2336	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2337	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2338	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2339	HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2340	{
2341		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2342		.name = "Channel Mode",
2343		.info = alc_ch_mode_info,
2344		.get = alc_ch_mode_get,
2345		.put = alc_ch_mode_put,
2346	},
2347	{ } /* end */
2348};
2349
2350/* capture mixer elements */
2351static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2352			    struct snd_ctl_elem_info *uinfo)
2353{
2354	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2355	struct alc_spec *spec = codec->spec;
2356	int err;
2357
2358	mutex_lock(&codec->control_mutex);
2359	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2360						      HDA_INPUT);
2361	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2362	mutex_unlock(&codec->control_mutex);
2363	return err;
2364}
2365
2366static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2367			   unsigned int size, unsigned int __user *tlv)
2368{
2369	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2370	struct alc_spec *spec = codec->spec;
2371	int err;
2372
2373	mutex_lock(&codec->control_mutex);
2374	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2375						      HDA_INPUT);
2376	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2377	mutex_unlock(&codec->control_mutex);
2378	return err;
2379}
2380
2381typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2382			     struct snd_ctl_elem_value *ucontrol);
2383
2384static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2385				 struct snd_ctl_elem_value *ucontrol,
2386				 getput_call_t func)
2387{
2388	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2389	struct alc_spec *spec = codec->spec;
2390	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2391	int err;
2392
2393	mutex_lock(&codec->control_mutex);
2394	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2395						      3, 0, HDA_INPUT);
2396	err = func(kcontrol, ucontrol);
2397	mutex_unlock(&codec->control_mutex);
2398	return err;
2399}
2400
2401static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2402			   struct snd_ctl_elem_value *ucontrol)
2403{
2404	return alc_cap_getput_caller(kcontrol, ucontrol,
2405				     snd_hda_mixer_amp_volume_get);
2406}
2407
2408static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2409			   struct snd_ctl_elem_value *ucontrol)
2410{
2411	return alc_cap_getput_caller(kcontrol, ucontrol,
2412				     snd_hda_mixer_amp_volume_put);
2413}
2414
2415/* capture mixer elements */
2416#define alc_cap_sw_info		snd_ctl_boolean_stereo_info
2417
2418static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2419			  struct snd_ctl_elem_value *ucontrol)
2420{
2421	return alc_cap_getput_caller(kcontrol, ucontrol,
2422				     snd_hda_mixer_amp_switch_get);
2423}
2424
2425static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2426			  struct snd_ctl_elem_value *ucontrol)
2427{
2428	return alc_cap_getput_caller(kcontrol, ucontrol,
2429				     snd_hda_mixer_amp_switch_put);
2430}
2431
2432#define _DEFINE_CAPMIX(num) \
2433	{ \
2434		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2435		.name = "Capture Switch", \
2436		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2437		.count = num, \
2438		.info = alc_cap_sw_info, \
2439		.get = alc_cap_sw_get, \
2440		.put = alc_cap_sw_put, \
2441	}, \
2442	{ \
2443		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2444		.name = "Capture Volume", \
2445		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2446			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2447			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2448		.count = num, \
2449		.info = alc_cap_vol_info, \
2450		.get = alc_cap_vol_get, \
2451		.put = alc_cap_vol_put, \
2452		.tlv = { .c = alc_cap_vol_tlv }, \
2453	}
2454
2455#define _DEFINE_CAPSRC(num) \
2456	{ \
2457		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2458		/* .name = "Capture Source", */ \
2459		.name = "Input Source", \
2460		.count = num, \
2461		.info = alc_mux_enum_info, \
2462		.get = alc_mux_enum_get, \
2463		.put = alc_mux_enum_put, \
2464	}
2465
2466#define DEFINE_CAPMIX(num) \
2467static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2468	_DEFINE_CAPMIX(num),				      \
2469	_DEFINE_CAPSRC(num),				      \
2470	{ } /* end */					      \
2471}
2472
2473#define DEFINE_CAPMIX_NOSRC(num) \
2474static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2475	_DEFINE_CAPMIX(num),					    \
2476	{ } /* end */						    \
2477}
2478
2479/* up to three ADCs */
2480DEFINE_CAPMIX(1);
2481DEFINE_CAPMIX(2);
2482DEFINE_CAPMIX(3);
2483DEFINE_CAPMIX_NOSRC(1);
2484DEFINE_CAPMIX_NOSRC(2);
2485DEFINE_CAPMIX_NOSRC(3);
2486
2487/*
2488 * ALC880 5-stack model
2489 *
2490 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2491 *      Side = 0x02 (0xd)
2492 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2493 *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2494 */
2495
2496/* additional mixers to alc880_three_stack_mixer */
2497static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2498	HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2499	HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2500	{ } /* end */
2501};
2502
2503/* channel source setting (6/8 channel selection for 5-stack) */
2504/* 6ch mode */
2505static struct hda_verb alc880_fivestack_ch6_init[] = {
2506	/* set line-in to input, mute it */
2507	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2508	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2509	{ } /* end */
2510};
2511
2512/* 8ch mode */
2513static struct hda_verb alc880_fivestack_ch8_init[] = {
2514	/* set line-in to output, unmute it */
2515	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2516	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2517	{ } /* end */
2518};
2519
2520static struct hda_channel_mode alc880_fivestack_modes[2] = {
2521	{ 6, alc880_fivestack_ch6_init },
2522	{ 8, alc880_fivestack_ch8_init },
2523};
2524
2525
2526/*
2527 * ALC880 6-stack model
2528 *
2529 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2530 *      Side = 0x05 (0x0f)
2531 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2532 *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2533 */
2534
2535static hda_nid_t alc880_6st_dac_nids[4] = {
2536	/* front, rear, clfe, rear_surr */
2537	0x02, 0x03, 0x04, 0x05
2538};
2539
2540static struct hda_input_mux alc880_6stack_capture_source = {
2541	.num_items = 4,
2542	.items = {
2543		{ "Mic", 0x0 },
2544		{ "Front Mic", 0x1 },
2545		{ "Line", 0x2 },
2546		{ "CD", 0x4 },
2547	},
2548};
2549
2550/* fixed 8-channels */
2551static struct hda_channel_mode alc880_sixstack_modes[1] = {
2552	{ 8, NULL },
2553};
2554
2555static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2556	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2557	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2558	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2559	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2560	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2561	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2562	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2563	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2564	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2565	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2566	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2567	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2568	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2569	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2570	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2571	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2572	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2573	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2574	{
2575		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2576		.name = "Channel Mode",
2577		.info = alc_ch_mode_info,
2578		.get = alc_ch_mode_get,
2579		.put = alc_ch_mode_put,
2580	},
2581	{ } /* end */
2582};
2583
2584
2585/*
2586 * ALC880 W810 model
2587 *
2588 * W810 has rear IO for:
2589 * Front (DAC 02)
2590 * Surround (DAC 03)
2591 * Center/LFE (DAC 04)
2592 * Digital out (06)
2593 *
2594 * The system also has a pair of internal speakers, and a headphone jack.
2595 * These are both connected to Line2 on the codec, hence to DAC 02.
2596 *
2597 * There is a variable resistor to control the speaker or headphone
2598 * volume. This is a hardware-only device without a software API.
2599 *
2600 * Plugging headphones in will disable the internal speakers. This is
2601 * implemented in hardware, not via the driver using jack sense. In
2602 * a similar fashion, plugging into the rear socket marked "front" will
2603 * disable both the speakers and headphones.
2604 *
2605 * For input, there's a microphone jack, and an "audio in" jack.
2606 * These may not do anything useful with this driver yet, because I
2607 * haven't setup any initialization verbs for these yet...
2608 */
2609
2610static hda_nid_t alc880_w810_dac_nids[3] = {
2611	/* front, rear/surround, clfe */
2612	0x02, 0x03, 0x04
2613};
2614
2615/* fixed 6 channels */
2616static struct hda_channel_mode alc880_w810_modes[1] = {
2617	{ 6, NULL }
2618};
2619
2620/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2621static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2622	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2623	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2624	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2625	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2626	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2627	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2628	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2629	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2630	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2631	{ } /* end */
2632};
2633
2634
2635/*
2636 * Z710V model
2637 *
2638 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2639 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2640 *                 Line = 0x1a
2641 */
2642
2643static hda_nid_t alc880_z71v_dac_nids[1] = {
2644	0x02
2645};
2646#define ALC880_Z71V_HP_DAC	0x03
2647
2648/* fixed 2 channels */
2649static struct hda_channel_mode alc880_2_jack_modes[1] = {
2650	{ 2, NULL }
2651};
2652
2653static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2654	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2655	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2656	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2657	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2658	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2659	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2660	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2661	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2662	{ } /* end */
2663};
2664
2665
2666/*
2667 * ALC880 F1734 model
2668 *
2669 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2670 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2671 */
2672
2673static hda_nid_t alc880_f1734_dac_nids[1] = {
2674	0x03
2675};
2676#define ALC880_F1734_HP_DAC	0x02
2677
2678static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2679	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2680	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2681	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2682	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2683	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2684	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2685	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2686	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2687	{ } /* end */
2688};
2689
2690static struct hda_input_mux alc880_f1734_capture_source = {
2691	.num_items = 2,
2692	.items = {
2693		{ "Mic", 0x1 },
2694		{ "CD", 0x4 },
2695	},
2696};
2697
2698
2699/*
2700 * ALC880 ASUS model
2701 *
2702 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2703 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2704 *  Mic = 0x18, Line = 0x1a
2705 */
2706
2707#define alc880_asus_dac_nids	alc880_w810_dac_nids	/* identical with w810 */
2708#define alc880_asus_modes	alc880_threestack_modes	/* 2/6 channel mode */
2709
2710static struct snd_kcontrol_new alc880_asus_mixer[] = {
2711	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2712	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2713	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2714	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2715	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2716	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2717	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2718	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2719	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2720	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2721	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2722	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2723	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2724	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2725	{
2726		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2727		.name = "Channel Mode",
2728		.info = alc_ch_mode_info,
2729		.get = alc_ch_mode_get,
2730		.put = alc_ch_mode_put,
2731	},
2732	{ } /* end */
2733};
2734
2735/*
2736 * ALC880 ASUS W1V model
2737 *
2738 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2739 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2740 *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2741 */
2742
2743/* additional mixers to alc880_asus_mixer */
2744static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2745	HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2746	HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2747	{ } /* end */
2748};
2749
2750/* TCL S700 */
2751static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2752	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2753	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2754	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2755	HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2756	HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2757	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2758	HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2759	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2760	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2761	{ } /* end */
2762};
2763
2764/* Uniwill */
2765static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2766	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2767	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2768	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2769	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2770	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2771	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2772	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2773	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2774	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2775	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2776	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2777	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2778	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2779	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2780	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2781	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2782	{
2783		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2784		.name = "Channel Mode",
2785		.info = alc_ch_mode_info,
2786		.get = alc_ch_mode_get,
2787		.put = alc_ch_mode_put,
2788	},
2789	{ } /* end */
2790};
2791
2792static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2793	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2794	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2795	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2796	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2797	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2798	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2799	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2800	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2801	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2802	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2803	{ } /* end */
2804};
2805
2806static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2807	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2808	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2809	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2810	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2811	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2812	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2813	{ } /* end */
2814};
2815
2816/*
2817 * virtual master controls
2818 */
2819
2820/*
2821 * slave controls for virtual master
2822 */
2823static const char *alc_slave_vols[] = {
2824	"Front Playback Volume",
2825	"Surround Playback Volume",
2826	"Center Playback Volume",
2827	"LFE Playback Volume",
2828	"Side Playback Volume",
2829	"Headphone Playback Volume",
2830	"Speaker Playback Volume",
2831	"Mono Playback Volume",
2832	"Line-Out Playback Volume",
2833	"PCM Playback Volume",
2834	NULL,
2835};
2836
2837static const char *alc_slave_sws[] = {
2838	"Front Playback Switch",
2839	"Surround Playback Switch",
2840	"Center Playback Switch",
2841	"LFE Playback Switch",
2842	"Side Playback Switch",
2843	"Headphone Playback Switch",
2844	"Speaker Playback Switch",
2845	"Mono Playback Switch",
2846	"IEC958 Playback Switch",
2847	"Line-Out Playback Switch",
2848	"PCM Playback Switch",
2849	NULL,
2850};
2851
2852/*
2853 * build control elements
2854 */
2855
2856#define NID_MAPPING		(-1)
2857
2858#define SUBDEV_SPEAKER_		(0 << 6)
2859#define SUBDEV_HP_		(1 << 6)
2860#define SUBDEV_LINE_		(2 << 6)
2861#define SUBDEV_SPEAKER(x)	(SUBDEV_SPEAKER_ | ((x) & 0x3f))
2862#define SUBDEV_HP(x)		(SUBDEV_HP_ | ((x) & 0x3f))
2863#define SUBDEV_LINE(x)		(SUBDEV_LINE_ | ((x) & 0x3f))
2864
2865static void alc_free_kctls(struct hda_codec *codec);
2866
2867#ifdef CONFIG_SND_HDA_INPUT_BEEP
2868/* additional beep mixers; the actual parameters are overwritten at build */
2869static struct snd_kcontrol_new alc_beep_mixer[] = {
2870	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2871	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2872	{ } /* end */
2873};
2874#endif
2875
2876static int alc_build_controls(struct hda_codec *codec)
2877{
2878	struct alc_spec *spec = codec->spec;
2879	struct snd_kcontrol *kctl = NULL;
2880	struct snd_kcontrol_new *knew;
2881	int i, j, err;
2882	unsigned int u;
2883	hda_nid_t nid;
2884
2885	for (i = 0; i < spec->num_mixers; i++) {
2886		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2887		if (err < 0)
2888			return err;
2889	}
2890	if (spec->cap_mixer) {
2891		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2892		if (err < 0)
2893			return err;
2894	}
2895	if (spec->multiout.dig_out_nid) {
2896		err = snd_hda_create_spdif_out_ctls(codec,
2897						    spec->multiout.dig_out_nid);
2898		if (err < 0)
2899			return err;
2900		if (!spec->no_analog) {
2901			err = snd_hda_create_spdif_share_sw(codec,
2902							    &spec->multiout);
2903			if (err < 0)
2904				return err;
2905			spec->multiout.share_spdif = 1;
2906		}
2907	}
2908	if (spec->dig_in_nid) {
2909		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2910		if (err < 0)
2911			return err;
2912	}
2913
2914#ifdef CONFIG_SND_HDA_INPUT_BEEP
2915	/* create beep controls if needed */
2916	if (spec->beep_amp) {
2917		struct snd_kcontrol_new *knew;
2918		for (knew = alc_beep_mixer; knew->name; knew++) {
2919			struct snd_kcontrol *kctl;
2920			kctl = snd_ctl_new1(knew, codec);
2921			if (!kctl)
2922				return -ENOMEM;
2923			kctl->private_value = spec->beep_amp;
2924			err = snd_hda_ctl_add(codec, 0, kctl);
2925			if (err < 0)
2926				return err;
2927		}
2928	}
2929#endif
2930
2931	/* if we have no master control, let's create it */
2932	if (!spec->no_analog &&
2933	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2934		unsigned int vmaster_tlv[4];
2935		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2936					HDA_OUTPUT, vmaster_tlv);
2937		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2938					  vmaster_tlv, alc_slave_vols);
2939		if (err < 0)
2940			return err;
2941	}
2942	if (!spec->no_analog &&
2943	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2944		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2945					  NULL, alc_slave_sws);
2946		if (err < 0)
2947			return err;
2948	}
2949
2950	/* assign Capture Source enums to NID */
2951	if (spec->capsrc_nids || spec->adc_nids) {
2952		kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2953		if (!kctl)
2954			kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2955		for (i = 0; kctl && i < kctl->count; i++) {
2956			hda_nid_t *nids = spec->capsrc_nids;
2957			if (!nids)
2958				nids = spec->adc_nids;
2959			err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2960			if (err < 0)
2961				return err;
2962		}
2963	}
2964	if (spec->cap_mixer) {
2965		const char *kname = kctl ? kctl->id.name : NULL;
2966		for (knew = spec->cap_mixer; knew->name; knew++) {
2967			if (kname && strcmp(knew->name, kname) == 0)
2968				continue;
2969			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2970			for (i = 0; kctl && i < kctl->count; i++) {
2971				err = snd_hda_add_nid(codec, kctl, i,
2972						      spec->adc_nids[i]);
2973				if (err < 0)
2974					return err;
2975			}
2976		}
2977	}
2978
2979	/* other nid->control mapping */
2980	for (i = 0; i < spec->num_mixers; i++) {
2981		for (knew = spec->mixers[i]; knew->name; knew++) {
2982			if (knew->iface != NID_MAPPING)
2983				continue;
2984			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2985			if (kctl == NULL)
2986				continue;
2987			u = knew->subdevice;
2988			for (j = 0; j < 4; j++, u >>= 8) {
2989				nid = u & 0x3f;
2990				if (nid == 0)
2991					continue;
2992				switch (u & 0xc0) {
2993				case SUBDEV_SPEAKER_:
2994					nid = spec->autocfg.speaker_pins[nid];
2995					break;
2996				case SUBDEV_LINE_:
2997					nid = spec->autocfg.line_out_pins[nid];
2998					break;
2999				case SUBDEV_HP_:
3000					nid = spec->autocfg.hp_pins[nid];
3001					break;
3002				default:
3003					continue;
3004				}
3005				err = snd_hda_add_nid(codec, kctl, 0, nid);
3006				if (err < 0)
3007					return err;
3008			}
3009			u = knew->private_value;
3010			for (j = 0; j < 4; j++, u >>= 8) {
3011				nid = u & 0xff;
3012				if (nid == 0)
3013					continue;
3014				err = snd_hda_add_nid(codec, kctl, 0, nid);
3015				if (err < 0)
3016					return err;
3017			}
3018		}
3019	}
3020
3021	alc_free_kctls(codec); /* no longer needed */
3022
3023	return 0;
3024}
3025
3026
3027/*
3028 * initialize the codec volumes, etc
3029 */
3030
3031/*
3032 * generic initialization of ADC, input mixers and output mixers
3033 */
3034static struct hda_verb alc880_volume_init_verbs[] = {
3035	/*
3036	 * Unmute ADC0-2 and set the default input to mic-in
3037	 */
3038	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3039	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3040	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3041	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3042	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3043	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3044
3045	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3046	 * mixer widget
3047	 * Note: PASD motherboards uses the Line In 2 as the input for front
3048	 * panel mic (mic 2)
3049	 */
3050	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3051	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3052	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3053	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3054	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3055	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3056	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3057	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3058
3059	/*
3060	 * Set up output mixers (0x0c - 0x0f)
3061	 */
3062	/* set vol=0 to output mixers */
3063	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3064	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3065	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3066	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3067	/* set up input amps for analog loopback */
3068	/* Amp Indices: DAC = 0, mixer = 1 */
3069	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3070	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3071	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3072	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3073	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3074	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3075	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3076	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3077
3078	{ }
3079};
3080
3081/*
3082 * 3-stack pin configuration:
3083 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3084 */
3085static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3086	/*
3087	 * preset connection lists of input pins
3088	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3089	 */
3090	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3091	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3092	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3093
3094	/*
3095	 * Set pin mode and muting
3096	 */
3097	/* set front pin widgets 0x14 for output */
3098	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3099	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3100	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3101	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3102	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3103	/* Mic2 (as headphone out) for HP output */
3104	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3105	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3106	/* Line In pin widget for input */
3107	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3108	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3109	/* Line2 (as front mic) pin widget for input and vref at 80% */
3110	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3111	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3112	/* CD pin widget for input */
3113	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3114
3115	{ }
3116};
3117
3118/*
3119 * 5-stack pin configuration:
3120 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3121 * line-in/side = 0x1a, f-mic = 0x1b
3122 */
3123static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3124	/*
3125	 * preset connection lists of input pins
3126	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3127	 */
3128	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3129	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3130
3131	/*
3132	 * Set pin mode and muting
3133	 */
3134	/* set pin widgets 0x14-0x17 for output */
3135	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3136	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3137	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3138	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3139	/* unmute pins for output (no gain on this amp) */
3140	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3141	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3142	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3143	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3144
3145	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3146	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3147	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3148	/* Mic2 (as headphone out) for HP output */
3149	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3150	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3151	/* Line In pin widget for input */
3152	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3153	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3154	/* Line2 (as front mic) pin widget for input and vref at 80% */
3155	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3156	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3157	/* CD pin widget for input */
3158	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3159
3160	{ }
3161};
3162
3163/*
3164 * W810 pin configuration:
3165 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3166 */
3167static struct hda_verb alc880_pin_w810_init_verbs[] = {
3168	/* hphone/speaker input selector: front DAC */
3169	{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3170
3171	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3172	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3173	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3174	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3175	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3176	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3177
3178	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3179	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3180
3181	{ }
3182};
3183
3184/*
3185 * Z71V pin configuration:
3186 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3187 */
3188static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3189	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3190	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3191	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3192	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3193
3194	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3195	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3196	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3197	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3198
3199	{ }
3200};
3201
3202/*
3203 * 6-stack pin configuration:
3204 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3205 * f-mic = 0x19, line = 0x1a, HP = 0x1b
3206 */
3207static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3208	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3209
3210	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3211	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3212	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3213	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3214	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3215	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3216	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3217	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3218
3219	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3220	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3221	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3222	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3223	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3224	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3225	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3226	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3227	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3228
3229	{ }
3230};
3231
3232/*
3233 * Uniwill pin configuration:
3234 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3235 * line = 0x1a
3236 */
3237static struct hda_verb alc880_uniwill_init_verbs[] = {
3238	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3239
3240	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3241	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3242	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3243	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3244	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3245	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3246	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3247	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3248	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3249	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3250	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3251	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3252	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3253	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3254
3255	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3256	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3257	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3258	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3259	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3260	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3261	/* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3262	/* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3263	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3264
3265	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3266	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3267
3268	{ }
3269};
3270
3271/*
3272* Uniwill P53
3273* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3274 */
3275static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3276	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3277
3278	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3279	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3280	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3281	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3282	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3283	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3284	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3285	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3286	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3287	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3288	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3289	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3290
3291	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3292	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3293	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3294	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3295	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3296	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3297
3298	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3299	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3300
3301	{ }
3302};
3303
3304static struct hda_verb alc880_beep_init_verbs[] = {
3305	{ 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3306	{ }
3307};
3308
3309/* auto-toggle front mic */
3310static void alc880_uniwill_mic_automute(struct hda_codec *codec)
3311{
3312 	unsigned int present;
3313	unsigned char bits;
3314
3315	present = snd_hda_jack_detect(codec, 0x18);
3316	bits = present ? HDA_AMP_MUTE : 0;
3317	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3318}
3319
3320static void alc880_uniwill_setup(struct hda_codec *codec)
3321{
3322	struct alc_spec *spec = codec->spec;
3323
3324	spec->autocfg.hp_pins[0] = 0x14;
3325	spec->autocfg.speaker_pins[0] = 0x15;
3326	spec->autocfg.speaker_pins[0] = 0x16;
3327}
3328
3329static void alc880_uniwill_init_hook(struct hda_codec *codec)
3330{
3331	alc_automute_amp(codec);
3332	alc880_uniwill_mic_automute(codec);
3333}
3334
3335static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3336				       unsigned int res)
3337{
3338	/* Looks like the unsol event is incompatible with the standard
3339	 * definition.  4bit tag is placed at 28 bit!
3340	 */
3341	switch (res >> 28) {
3342	case ALC880_MIC_EVENT:
3343		alc880_uniwill_mic_automute(codec);
3344		break;
3345	default:
3346		alc_automute_amp_unsol_event(codec, res);
3347		break;
3348	}
3349}
3350
3351static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3352{
3353	struct alc_spec *spec = codec->spec;
3354
3355	spec->autocfg.hp_pins[0] = 0x14;
3356	spec->autocfg.speaker_pins[0] = 0x15;
3357}
3358
3359static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3360{
3361	unsigned int present;
3362
3363	present = snd_hda_codec_read(codec, 0x21, 0,
3364				     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3365	present &= HDA_AMP_VOLMASK;
3366	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3367				 HDA_AMP_VOLMASK, present);
3368	snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3369				 HDA_AMP_VOLMASK, present);
3370}
3371
3372static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3373					   unsigned int res)
3374{
3375	/* Looks like the unsol event is incompatible with the standard
3376	 * definition.  4bit tag is placed at 28 bit!
3377	 */
3378	if ((res >> 28) == ALC880_DCVOL_EVENT)
3379		alc880_uniwill_p53_dcvol_automute(codec);
3380	else
3381		alc_automute_amp_unsol_event(codec, res);
3382}
3383
3384/*
3385 * F1734 pin configuration:
3386 * HP = 0x14, speaker-out = 0x15, mic = 0x18
3387 */
3388static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3389	{0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3390	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3391	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3392	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3393	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3394
3395	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3396	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3397	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3398	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3399
3400	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3401	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3402	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3403	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3404	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3405	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3406	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3407	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3408	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3409
3410	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3411	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3412
3413	{ }
3414};
3415
3416/*
3417 * ASUS pin configuration:
3418 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3419 */
3420static struct hda_verb alc880_pin_asus_init_verbs[] = {
3421	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3422	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3423	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3424	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3425
3426	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3427	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3428	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3429	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3430	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3431	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3432	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3433	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3434
3435	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3436	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3437	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3438	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3439	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3440	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3441	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3442	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3443	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3444
3445	{ }
3446};
3447
3448/* Enable GPIO mask and set output */
3449#define alc880_gpio1_init_verbs	alc_gpio1_init_verbs
3450#define alc880_gpio2_init_verbs	alc_gpio2_init_verbs
3451#define alc880_gpio3_init_verbs	alc_gpio3_init_verbs
3452
3453/* Clevo m520g init */
3454static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3455	/* headphone output */
3456	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3457	/* line-out */
3458	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3459	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3460	/* Line-in */
3461	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3462	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3463	/* CD */
3464	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3465	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3466	/* Mic1 (rear panel) */
3467	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3468	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3469	/* Mic2 (front panel) */
3470	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3471	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3472	/* headphone */
3473	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3474	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475        /* change to EAPD mode */
3476	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3477	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3478
3479	{ }
3480};
3481
3482static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3483	/* change to EAPD mode */
3484	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3485	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3486
3487	/* Headphone output */
3488	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3489	/* Front output*/
3490	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3491	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3492
3493	/* Line In pin widget for input */
3494	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3495	/* CD pin widget for input */
3496	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3497	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3498	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3499
3500	/* change to EAPD mode */
3501	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3502	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3503
3504	{ }
3505};
3506
3507/*
3508 * LG m1 express dual
3509 *
3510 * Pin assignment:
3511 *   Rear Line-In/Out (blue): 0x14
3512 *   Build-in Mic-In: 0x15
3513 *   Speaker-out: 0x17
3514 *   HP-Out (green): 0x1b
3515 *   Mic-In/Out (red): 0x19
3516 *   SPDIF-Out: 0x1e
3517 */
3518
3519/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3520static hda_nid_t alc880_lg_dac_nids[3] = {
3521	0x05, 0x02, 0x03
3522};
3523
3524/* seems analog CD is not working */
3525static struct hda_input_mux alc880_lg_capture_source = {
3526	.num_items = 3,
3527	.items = {
3528		{ "Mic", 0x1 },
3529		{ "Line", 0x5 },
3530		{ "Internal Mic", 0x6 },
3531	},
3532};
3533
3534/* 2,4,6 channel modes */
3535static struct hda_verb alc880_lg_ch2_init[] = {
3536	/* set line-in and mic-in to input */
3537	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3538	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3539	{ }
3540};
3541
3542static struct hda_verb alc880_lg_ch4_init[] = {
3543	/* set line-in to out and mic-in to input */
3544	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3545	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3546	{ }
3547};
3548
3549static struct hda_verb alc880_lg_ch6_init[] = {
3550	/* set line-in and mic-in to output */
3551	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3552	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3553	{ }
3554};
3555
3556static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3557	{ 2, alc880_lg_ch2_init },
3558	{ 4, alc880_lg_ch4_init },
3559	{ 6, alc880_lg_ch6_init },
3560};
3561
3562static struct snd_kcontrol_new alc880_lg_mixer[] = {
3563	HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3564	HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3565	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3566	HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3567	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3568	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3569	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3570	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3571	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3572	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3573	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3574	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3575	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3576	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3577	{
3578		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3579		.name = "Channel Mode",
3580		.info = alc_ch_mode_info,
3581		.get = alc_ch_mode_get,
3582		.put = alc_ch_mode_put,
3583	},
3584	{ } /* end */
3585};
3586
3587static struct hda_verb alc880_lg_init_verbs[] = {
3588	/* set capture source to mic-in */
3589	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3590	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3591	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3592	/* mute all amp mixer inputs */
3593	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3594	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3595	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3596	/* line-in to input */
3597	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3598	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3599	/* built-in mic */
3600	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3601	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3602	/* speaker-out */
3603	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3604	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3605	/* mic-in to input */
3606	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3607	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3608	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3609	/* HP-out */
3610	{0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3611	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3612	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3613	/* jack sense */
3614	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3615	{ }
3616};
3617
3618/* toggle speaker-output according to the hp-jack state */
3619static void alc880_lg_setup(struct hda_codec *codec)
3620{
3621	struct alc_spec *spec = codec->spec;
3622
3623	spec->autocfg.hp_pins[0] = 0x1b;
3624	spec->autocfg.speaker_pins[0] = 0x17;
3625}
3626
3627/*
3628 * LG LW20
3629 *
3630 * Pin assignment:
3631 *   Speaker-out: 0x14
3632 *   Mic-In: 0x18
3633 *   Built-in Mic-In: 0x19
3634 *   Line-In: 0x1b
3635 *   HP-Out: 0x1a
3636 *   SPDIF-Out: 0x1e
3637 */
3638
3639static struct hda_input_mux alc880_lg_lw_capture_source = {
3640	.num_items = 3,
3641	.items = {
3642		{ "Mic", 0x0 },
3643		{ "Internal Mic", 0x1 },
3644		{ "Line In", 0x2 },
3645	},
3646};
3647
3648#define alc880_lg_lw_modes alc880_threestack_modes
3649
3650static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3651	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3652	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3653	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3654	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3655	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3656	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3657	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3658	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3659	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3660	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3661	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3662	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3663	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3664	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3665	{
3666		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3667		.name = "Channel Mode",
3668		.info = alc_ch_mode_info,
3669		.get = alc_ch_mode_get,
3670		.put = alc_ch_mode_put,
3671	},
3672	{ } /* end */
3673};
3674
3675static struct hda_verb alc880_lg_lw_init_verbs[] = {
3676	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3677	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3678	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3679
3680	/* set capture source to mic-in */
3681	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3682	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3683	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3684	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3685	/* speaker-out */
3686	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3687	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3688	/* HP-out */
3689	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3690	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3691	/* mic-in to input */
3692	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3693	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3694	/* built-in mic */
3695	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3696	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3697	/* jack sense */
3698	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3699	{ }
3700};
3701
3702/* toggle speaker-output according to the hp-jack state */
3703static void alc880_lg_lw_setup(struct hda_codec *codec)
3704{
3705	struct alc_spec *spec = codec->spec;
3706
3707	spec->autocfg.hp_pins[0] = 0x1b;
3708	spec->autocfg.speaker_pins[0] = 0x14;
3709}
3710
3711static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3712	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3713	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3714	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3715	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3716	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3717	HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3718	{ } /* end */
3719};
3720
3721static struct hda_input_mux alc880_medion_rim_capture_source = {
3722	.num_items = 2,
3723	.items = {
3724		{ "Mic", 0x0 },
3725		{ "Internal Mic", 0x1 },
3726	},
3727};
3728
3729static struct hda_verb alc880_medion_rim_init_verbs[] = {
3730	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3731
3732	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3733	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3734
3735	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3736	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3737	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3738	/* Mic2 (as headphone out) for HP output */
3739	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3740	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3741	/* Internal Speaker */
3742	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3743	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3744
3745	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3746	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3747
3748	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3749	{ }
3750};
3751
3752/* toggle speaker-output according to the hp-jack state */
3753static void alc880_medion_rim_automute(struct hda_codec *codec)
3754{
3755	struct alc_spec *spec = codec->spec;
3756	alc_automute_amp(codec);
3757	/* toggle EAPD */
3758	if (spec->jack_present)
3759		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3760	else
3761		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3762}
3763
3764static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3765					  unsigned int res)
3766{
3767	/* Looks like the unsol event is incompatible with the standard
3768	 * definition.  4bit tag is placed at 28 bit!
3769	 */
3770	if ((res >> 28) == ALC880_HP_EVENT)
3771		alc880_medion_rim_automute(codec);
3772}
3773
3774static void alc880_medion_rim_setup(struct hda_codec *codec)
3775{
3776	struct alc_spec *spec = codec->spec;
3777
3778	spec->autocfg.hp_pins[0] = 0x14;
3779	spec->autocfg.speaker_pins[0] = 0x1b;
3780}
3781
3782#ifdef CONFIG_SND_HDA_POWER_SAVE
3783static struct hda_amp_list alc880_loopbacks[] = {
3784	{ 0x0b, HDA_INPUT, 0 },
3785	{ 0x0b, HDA_INPUT, 1 },
3786	{ 0x0b, HDA_INPUT, 2 },
3787	{ 0x0b, HDA_INPUT, 3 },
3788	{ 0x0b, HDA_INPUT, 4 },
3789	{ } /* end */
3790};
3791
3792static struct hda_amp_list alc880_lg_loopbacks[] = {
3793	{ 0x0b, HDA_INPUT, 1 },
3794	{ 0x0b, HDA_INPUT, 6 },
3795	{ 0x0b, HDA_INPUT, 7 },
3796	{ } /* end */
3797};
3798#endif
3799
3800/*
3801 * Common callbacks
3802 */
3803
3804static int alc_init(struct hda_codec *codec)
3805{
3806	struct alc_spec *spec = codec->spec;
3807	unsigned int i;
3808
3809	alc_fix_pll(codec);
3810	alc_auto_init_amp(codec, spec->init_amp);
3811
3812	for (i = 0; i < spec->num_init_verbs; i++)
3813		snd_hda_sequence_write(codec, spec->init_verbs[i]);
3814
3815	if (spec->init_hook)
3816		spec->init_hook(codec);
3817
3818	hda_call_check_power_status(codec, 0x01);
3819	return 0;
3820}
3821
3822static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3823{
3824	struct alc_spec *spec = codec->spec;
3825
3826	if (spec->unsol_event)
3827		spec->unsol_event(codec, res);
3828}
3829
3830#ifdef CONFIG_SND_HDA_POWER_SAVE
3831static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3832{
3833	struct alc_spec *spec = codec->spec;
3834	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3835}
3836#endif
3837
3838/*
3839 * Analog playback callbacks
3840 */
3841static int alc880_playback_pcm_open(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	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3847					     hinfo);
3848}
3849
3850static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3851				       struct hda_codec *codec,
3852				       unsigned int stream_tag,
3853				       unsigned int format,
3854				       struct snd_pcm_substream *substream)
3855{
3856	struct alc_spec *spec = codec->spec;
3857	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3858						stream_tag, format, substream);
3859}
3860
3861static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3862				       struct hda_codec *codec,
3863				       struct snd_pcm_substream *substream)
3864{
3865	struct alc_spec *spec = codec->spec;
3866	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3867}
3868
3869/*
3870 * Digital out
3871 */
3872static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3873					struct hda_codec *codec,
3874					struct snd_pcm_substream *substream)
3875{
3876	struct alc_spec *spec = codec->spec;
3877	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3878}
3879
3880static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3881					   struct hda_codec *codec,
3882					   unsigned int stream_tag,
3883					   unsigned int format,
3884					   struct snd_pcm_substream *substream)
3885{
3886	struct alc_spec *spec = codec->spec;
3887	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3888					     stream_tag, format, substream);
3889}
3890
3891static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3892					   struct hda_codec *codec,
3893					   struct snd_pcm_substream *substream)
3894{
3895	struct alc_spec *spec = codec->spec;
3896	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3897}
3898
3899static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3900					 struct hda_codec *codec,
3901					 struct snd_pcm_substream *substream)
3902{
3903	struct alc_spec *spec = codec->spec;
3904	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3905}
3906
3907/*
3908 * Analog capture
3909 */
3910static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3911				      struct hda_codec *codec,
3912				      unsigned int stream_tag,
3913				      unsigned int format,
3914				      struct snd_pcm_substream *substream)
3915{
3916	struct alc_spec *spec = codec->spec;
3917
3918	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3919				   stream_tag, 0, format);
3920	return 0;
3921}
3922
3923static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3924				      struct hda_codec *codec,
3925				      struct snd_pcm_substream *substream)
3926{
3927	struct alc_spec *spec = codec->spec;
3928
3929	snd_hda_codec_cleanup_stream(codec,
3930				     spec->adc_nids[substream->number + 1]);
3931	return 0;
3932}
3933
3934/* analog capture with dynamic dual-adc changes */
3935static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3936				       struct hda_codec *codec,
3937				       unsigned int stream_tag,
3938				       unsigned int format,
3939				       struct snd_pcm_substream *substream)
3940{
3941	struct alc_spec *spec = codec->spec;
3942	spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3943	spec->cur_adc_stream_tag = stream_tag;
3944	spec->cur_adc_format = format;
3945	snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3946	return 0;
3947}
3948
3949static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3950				       struct hda_codec *codec,
3951				       struct snd_pcm_substream *substream)
3952{
3953	struct alc_spec *spec = codec->spec;
3954	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3955	spec->cur_adc = 0;
3956	return 0;
3957}
3958
3959static struct hda_pcm_stream dualmic_pcm_analog_capture = {
3960	.substreams = 1,
3961	.channels_min = 2,
3962	.channels_max = 2,
3963	.nid = 0, /* fill later */
3964	.ops = {
3965		.prepare = dualmic_capture_pcm_prepare,
3966		.cleanup = dualmic_capture_pcm_cleanup
3967	},
3968};
3969
3970/*
3971 */
3972static struct hda_pcm_stream alc880_pcm_analog_playback = {
3973	.substreams = 1,
3974	.channels_min = 2,
3975	.channels_max = 8,
3976	/* NID is set in alc_build_pcms */
3977	.ops = {
3978		.open = alc880_playback_pcm_open,
3979		.prepare = alc880_playback_pcm_prepare,
3980		.cleanup = alc880_playback_pcm_cleanup
3981	},
3982};
3983
3984static struct hda_pcm_stream alc880_pcm_analog_capture = {
3985	.substreams = 1,
3986	.channels_min = 2,
3987	.channels_max = 2,
3988	/* NID is set in alc_build_pcms */
3989};
3990
3991static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3992	.substreams = 1,
3993	.channels_min = 2,
3994	.channels_max = 2,
3995	/* NID is set in alc_build_pcms */
3996};
3997
3998static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3999	.substreams = 2, /* can be overridden */
4000	.channels_min = 2,
4001	.channels_max = 2,
4002	/* NID is set in alc_build_pcms */
4003	.ops = {
4004		.prepare = alc880_alt_capture_pcm_prepare,
4005		.cleanup = alc880_alt_capture_pcm_cleanup
4006	},
4007};
4008
4009static struct hda_pcm_stream alc880_pcm_digital_playback = {
4010	.substreams = 1,
4011	.channels_min = 2,
4012	.channels_max = 2,
4013	/* NID is set in alc_build_pcms */
4014	.ops = {
4015		.open = alc880_dig_playback_pcm_open,
4016		.close = alc880_dig_playback_pcm_close,
4017		.prepare = alc880_dig_playback_pcm_prepare,
4018		.cleanup = alc880_dig_playback_pcm_cleanup
4019	},
4020};
4021
4022static struct hda_pcm_stream alc880_pcm_digital_capture = {
4023	.substreams = 1,
4024	.channels_min = 2,
4025	.channels_max = 2,
4026	/* NID is set in alc_build_pcms */
4027};
4028
4029/* Used by alc_build_pcms to flag that a PCM has no playback stream */
4030static struct hda_pcm_stream alc_pcm_null_stream = {
4031	.substreams = 0,
4032	.channels_min = 0,
4033	.channels_max = 0,
4034};
4035
4036static int alc_build_pcms(struct hda_codec *codec)
4037{
4038	struct alc_spec *spec = codec->spec;
4039	struct hda_pcm *info = spec->pcm_rec;
4040	int i;
4041
4042	codec->num_pcms = 1;
4043	codec->pcm_info = info;
4044
4045	if (spec->no_analog)
4046		goto skip_analog;
4047
4048	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4049		 "%s Analog", codec->chip_name);
4050	info->name = spec->stream_name_analog;
4051
4052	if (spec->stream_analog_playback) {
4053		if (snd_BUG_ON(!spec->multiout.dac_nids))
4054			return -EINVAL;
4055		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4056		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4057	}
4058	if (spec->stream_analog_capture) {
4059		if (snd_BUG_ON(!spec->adc_nids))
4060			return -EINVAL;
4061		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4062		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4063	}
4064
4065	if (spec->channel_mode) {
4066		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4067		for (i = 0; i < spec->num_channel_mode; i++) {
4068			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4069				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4070			}
4071		}
4072	}
4073
4074 skip_analog:
4075	/* SPDIF for stream index #1 */
4076	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4077		snprintf(spec->stream_name_digital,
4078			 sizeof(spec->stream_name_digital),
4079			 "%s Digital", codec->chip_name);
4080		codec->num_pcms = 2;
4081	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4082		info = spec->pcm_rec + 1;
4083		info->name = spec->stream_name_digital;
4084		if (spec->dig_out_type)
4085			info->pcm_type = spec->dig_out_type;
4086		else
4087			info->pcm_type = HDA_PCM_TYPE_SPDIF;
4088		if (spec->multiout.dig_out_nid &&
4089		    spec->stream_digital_playback) {
4090			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4091			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4092		}
4093		if (spec->dig_in_nid &&
4094		    spec->stream_digital_capture) {
4095			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4096			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4097		}
4098		/* FIXME: do we need this for all Realtek codec models? */
4099		codec->spdif_status_reset = 1;
4100	}
4101
4102	if (spec->no_analog)
4103		return 0;
4104
4105	/* If the use of more than one ADC is requested for the current
4106	 * model, configure a second analog capture-only PCM.
4107	 */
4108	/* Additional Analaog capture for index #2 */
4109	if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4110	    (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4111		codec->num_pcms = 3;
4112		info = spec->pcm_rec + 2;
4113		info->name = spec->stream_name_analog;
4114		if (spec->alt_dac_nid) {
4115			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4116				*spec->stream_analog_alt_playback;
4117			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4118				spec->alt_dac_nid;
4119		} else {
4120			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4121				alc_pcm_null_stream;
4122			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4123		}
4124		if (spec->num_adc_nids > 1) {
4125			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4126				*spec->stream_analog_alt_capture;
4127			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4128				spec->adc_nids[1];
4129			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4130				spec->num_adc_nids - 1;
4131		} else {
4132			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4133				alc_pcm_null_stream;
4134			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4135		}
4136	}
4137
4138	return 0;
4139}
4140
4141static inline void alc_shutup(struct hda_codec *codec)
4142{
4143	snd_hda_shutup_pins(codec);
4144}
4145
4146static void alc_free_kctls(struct hda_codec *codec)
4147{
4148	struct alc_spec *spec = codec->spec;
4149
4150	if (spec->kctls.list) {
4151		struct snd_kcontrol_new *kctl = spec->kctls.list;
4152		int i;
4153		for (i = 0; i < spec->kctls.used; i++)
4154			kfree(kctl[i].name);
4155	}
4156	snd_array_free(&spec->kctls);
4157}
4158
4159static void alc_free(struct hda_codec *codec)
4160{
4161	struct alc_spec *spec = codec->spec;
4162
4163	if (!spec)
4164		return;
4165
4166	alc_shutup(codec);
4167	alc_free_kctls(codec);
4168	kfree(spec);
4169	snd_hda_detach_beep_device(codec);
4170}
4171
4172#ifdef CONFIG_SND_HDA_POWER_SAVE
4173static void alc_power_eapd(struct hda_codec *codec)
4174{
4175	/* We currently only handle front, HP */
4176	switch (codec->vendor_id) {
4177	case 0x10ec0260:
4178		set_eapd(codec, 0x0f, 0);
4179		set_eapd(codec, 0x10, 0);
4180		break;
4181	case 0x10ec0262:
4182	case 0x10ec0267:
4183	case 0x10ec0268:
4184	case 0x10ec0269:
4185	case 0x10ec0270:
4186	case 0x10ec0272:
4187	case 0x10ec0660:
4188	case 0x10ec0662:
4189	case 0x10ec0663:
4190	case 0x10ec0862:
4191	case 0x10ec0889:
4192		set_eapd(codec, 0x14, 0);
4193		set_eapd(codec, 0x15, 0);
4194		break;
4195	}
4196}
4197
4198static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4199{
4200	struct alc_spec *spec = codec->spec;
4201	alc_shutup(codec);
4202	if (spec && spec->power_hook)
4203		spec->power_hook(codec);
4204	return 0;
4205}
4206#endif
4207
4208#ifdef SND_HDA_NEEDS_RESUME
4209static int alc_resume(struct hda_codec *codec)
4210{
4211	codec->patch_ops.init(codec);
4212	snd_hda_codec_resume_amp(codec);
4213	snd_hda_codec_resume_cache(codec);
4214	hda_call_check_power_status(codec, 0x01);
4215	return 0;
4216}
4217#endif
4218
4219/*
4220 */
4221static struct hda_codec_ops alc_patch_ops = {
4222	.build_controls = alc_build_controls,
4223	.build_pcms = alc_build_pcms,
4224	.init = alc_init,
4225	.free = alc_free,
4226	.unsol_event = alc_unsol_event,
4227#ifdef SND_HDA_NEEDS_RESUME
4228	.resume = alc_resume,
4229#endif
4230#ifdef CONFIG_SND_HDA_POWER_SAVE
4231	.suspend = alc_suspend,
4232	.check_power_status = alc_check_power_status,
4233#endif
4234	.reboot_notify = alc_shutup,
4235};
4236
4237/* replace the codec chip_name with the given string */
4238static int alc_codec_rename(struct hda_codec *codec, const char *name)
4239{
4240	kfree(codec->chip_name);
4241	codec->chip_name = kstrdup(name, GFP_KERNEL);
4242	if (!codec->chip_name) {
4243		alc_free(codec);
4244		return -ENOMEM;
4245	}
4246	return 0;
4247}
4248
4249/*
4250 * Test configuration for debugging
4251 *
4252 * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4253 * enum controls.
4254 */
4255#ifdef CONFIG_SND_DEBUG
4256static hda_nid_t alc880_test_dac_nids[4] = {
4257	0x02, 0x03, 0x04, 0x05
4258};
4259
4260static struct hda_input_mux alc880_test_capture_source = {
4261	.num_items = 7,
4262	.items = {
4263		{ "In-1", 0x0 },
4264		{ "In-2", 0x1 },
4265		{ "In-3", 0x2 },
4266		{ "In-4", 0x3 },
4267		{ "CD", 0x4 },
4268		{ "Front", 0x5 },
4269		{ "Surround", 0x6 },
4270	},
4271};
4272
4273static struct hda_channel_mode alc880_test_modes[4] = {
4274	{ 2, NULL },
4275	{ 4, NULL },
4276	{ 6, NULL },
4277	{ 8, NULL },
4278};
4279
4280static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4281				 struct snd_ctl_elem_info *uinfo)
4282{
4283	static char *texts[] = {
4284		"N/A", "Line Out", "HP Out",
4285		"In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4286	};
4287	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4288	uinfo->count = 1;
4289	uinfo->value.enumerated.items = 8;
4290	if (uinfo->value.enumerated.item >= 8)
4291		uinfo->value.enumerated.item = 7;
4292	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4293	return 0;
4294}
4295
4296static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4297				struct snd_ctl_elem_value *ucontrol)
4298{
4299	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4300	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4301	unsigned int pin_ctl, item = 0;
4302
4303	pin_ctl = snd_hda_codec_read(codec, nid, 0,
4304				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4305	if (pin_ctl & AC_PINCTL_OUT_EN) {
4306		if (pin_ctl & AC_PINCTL_HP_EN)
4307			item = 2;
4308		else
4309			item = 1;
4310	} else if (pin_ctl & AC_PINCTL_IN_EN) {
4311		switch (pin_ctl & AC_PINCTL_VREFEN) {
4312		case AC_PINCTL_VREF_HIZ: item = 3; break;
4313		case AC_PINCTL_VREF_50:  item = 4; break;
4314		case AC_PINCTL_VREF_GRD: item = 5; break;
4315		case AC_PINCTL_VREF_80:  item = 6; break;
4316		case AC_PINCTL_VREF_100: item = 7; break;
4317		}
4318	}
4319	ucontrol->value.enumerated.item[0] = item;
4320	return 0;
4321}
4322
4323static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4324				struct snd_ctl_elem_value *ucontrol)
4325{
4326	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4327	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4328	static unsigned int ctls[] = {
4329		0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4330		AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4331		AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4332		AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4333		AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4334		AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4335	};
4336	unsigned int old_ctl, new_ctl;
4337
4338	old_ctl = snd_hda_codec_read(codec, nid, 0,
4339				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4340	new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4341	if (old_ctl != new_ctl) {
4342		int val;
4343		snd_hda_codec_write_cache(codec, nid, 0,
4344					  AC_VERB_SET_PIN_WIDGET_CONTROL,
4345					  new_ctl);
4346		val = ucontrol->value.enumerated.item[0] >= 3 ?
4347			HDA_AMP_MUTE : 0;
4348		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4349					 HDA_AMP_MUTE, val);
4350		return 1;
4351	}
4352	return 0;
4353}
4354
4355static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4356				 struct snd_ctl_elem_info *uinfo)
4357{
4358	static char *texts[] = {
4359		"Front", "Surround", "CLFE", "Side"
4360	};
4361	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4362	uinfo->count = 1;
4363	uinfo->value.enumerated.items = 4;
4364	if (uinfo->value.enumerated.item >= 4)
4365		uinfo->value.enumerated.item = 3;
4366	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4367	return 0;
4368}
4369
4370static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4371				struct snd_ctl_elem_value *ucontrol)
4372{
4373	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4374	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4375	unsigned int sel;
4376
4377	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4378	ucontrol->value.enumerated.item[0] = sel & 3;
4379	return 0;
4380}
4381
4382static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4383				struct snd_ctl_elem_value *ucontrol)
4384{
4385	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4386	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4387	unsigned int sel;
4388
4389	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4390	if (ucontrol->value.enumerated.item[0] != sel) {
4391		sel = ucontrol->value.enumerated.item[0] & 3;
4392		snd_hda_codec_write_cache(codec, nid, 0,
4393					  AC_VERB_SET_CONNECT_SEL, sel);
4394		return 1;
4395	}
4396	return 0;
4397}
4398
4399#define PIN_CTL_TEST(xname,nid) {			\
4400		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
4401			.name = xname,		       \
4402			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4403			.info = alc_test_pin_ctl_info, \
4404			.get = alc_test_pin_ctl_get,   \
4405			.put = alc_test_pin_ctl_put,   \
4406			.private_value = nid	       \
4407			}
4408
4409#define PIN_SRC_TEST(xname,nid) {			\
4410		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
4411			.name = xname,		       \
4412			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4413			.info = alc_test_pin_src_info, \
4414			.get = alc_test_pin_src_get,   \
4415			.put = alc_test_pin_src_put,   \
4416			.private_value = nid	       \
4417			}
4418
4419static struct snd_kcontrol_new alc880_test_mixer[] = {
4420	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4421	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4422	HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4423	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4424	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4425	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4426	HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4427	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4428	PIN_CTL_TEST("Front Pin Mode", 0x14),
4429	PIN_CTL_TEST("Surround Pin Mode", 0x15),
4430	PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4431	PIN_CTL_TEST("Side Pin Mode", 0x17),
4432	PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4433	PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4434	PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4435	PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4436	PIN_SRC_TEST("In-1 Pin Source", 0x18),
4437	PIN_SRC_TEST("In-2 Pin Source", 0x19),
4438	PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4439	PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4440	HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4441	HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4442	HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4443	HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4444	HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4445	HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4446	HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4447	HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4448	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4449	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4450	{
4451		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4452		.name = "Channel Mode",
4453		.info = alc_ch_mode_info,
4454		.get = alc_ch_mode_get,
4455		.put = alc_ch_mode_put,
4456	},
4457	{ } /* end */
4458};
4459
4460static struct hda_verb alc880_test_init_verbs[] = {
4461	/* Unmute inputs of 0x0c - 0x0f */
4462	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4463	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4464	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4465	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4466	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4467	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4468	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4469	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4470	/* Vol output for 0x0c-0x0f */
4471	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4472	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4473	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4474	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4475	/* Set output pins 0x14-0x17 */
4476	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4477	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4478	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4479	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4480	/* Unmute output pins 0x14-0x17 */
4481	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4482	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4483	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4484	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4485	/* Set input pins 0x18-0x1c */
4486	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4487	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4488	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4489	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4490	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4491	/* Mute input pins 0x18-0x1b */
4492	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4493	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4494	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4495	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4496	/* ADC set up */
4497	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4498	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4499	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4500	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4501	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4502	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4503	/* Analog input/passthru */
4504	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4505	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4506	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4507	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4508	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4509	{ }
4510};
4511#endif
4512
4513/*
4514 */
4515
4516static const char *alc880_models[ALC880_MODEL_LAST] = {
4517	[ALC880_3ST]		= "3stack",
4518	[ALC880_TCL_S700]	= "tcl",
4519	[ALC880_3ST_DIG]	= "3stack-digout",
4520	[ALC880_CLEVO]		= "clevo",
4521	[ALC880_5ST]		= "5stack",
4522	[ALC880_5ST_DIG]	= "5stack-digout",
4523	[ALC880_W810]		= "w810",
4524	[ALC880_Z71V]		= "z71v",
4525	[ALC880_6ST]		= "6stack",
4526	[ALC880_6ST_DIG]	= "6stack-digout",
4527	[ALC880_ASUS]		= "asus",
4528	[ALC880_ASUS_W1V]	= "asus-w1v",
4529	[ALC880_ASUS_DIG]	= "asus-dig",
4530	[ALC880_ASUS_DIG2]	= "asus-dig2",
4531	[ALC880_UNIWILL_DIG]	= "uniwill",
4532	[ALC880_UNIWILL_P53]	= "uniwill-p53",
4533	[ALC880_FUJITSU]	= "fujitsu",
4534	[ALC880_F1734]		= "F1734",
4535	[ALC880_LG]		= "lg",
4536	[ALC880_LG_LW]		= "lg-lw",
4537	[ALC880_MEDION_RIM]	= "medion",
4538#ifdef CONFIG_SND_DEBUG
4539	[ALC880_TEST]		= "test",
4540#endif
4541	[ALC880_AUTO]		= "auto",
4542};
4543
4544static struct snd_pci_quirk alc880_cfg_tbl[] = {
4545	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4546	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4547	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4548	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4549	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4550	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4551	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4552	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4553	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4554	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4555	SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4556	SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4557	SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4558	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4559	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4560	SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4561	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4562	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4563	/* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4564	SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4565	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4566	SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4567	SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4568	SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4569	SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4570	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4571	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4572	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4573	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4574	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4575	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4576	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4577	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4578	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4579	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4580	SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4581	SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4582	SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4583	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4584	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4585	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4586	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4587	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4588	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4589	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4590	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4591	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4592	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4593	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4594	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4595	SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4596	SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4597	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4598	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4599	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4600	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4601	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4602	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4603	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4604	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4605	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4606	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4607	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4608	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4609	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4610	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4611	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4612	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4613	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4614	/* default Intel */
4615	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4616	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4617	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4618	{}
4619};
4620
4621/*
4622 * ALC880 codec presets
4623 */
4624static struct alc_config_preset alc880_presets[] = {
4625	[ALC880_3ST] = {
4626		.mixers = { alc880_three_stack_mixer },
4627		.init_verbs = { alc880_volume_init_verbs,
4628				alc880_pin_3stack_init_verbs },
4629		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4630		.dac_nids = alc880_dac_nids,
4631		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4632		.channel_mode = alc880_threestack_modes,
4633		.need_dac_fix = 1,
4634		.input_mux = &alc880_capture_source,
4635	},
4636	[ALC880_3ST_DIG] = {
4637		.mixers = { alc880_three_stack_mixer },
4638		.init_verbs = { alc880_volume_init_verbs,
4639				alc880_pin_3stack_init_verbs },
4640		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4641		.dac_nids = alc880_dac_nids,
4642		.dig_out_nid = ALC880_DIGOUT_NID,
4643		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4644		.channel_mode = alc880_threestack_modes,
4645		.need_dac_fix = 1,
4646		.input_mux = &alc880_capture_source,
4647	},
4648	[ALC880_TCL_S700] = {
4649		.mixers = { alc880_tcl_s700_mixer },
4650		.init_verbs = { alc880_volume_init_verbs,
4651				alc880_pin_tcl_S700_init_verbs,
4652				alc880_gpio2_init_verbs },
4653		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4654		.dac_nids = alc880_dac_nids,
4655		.adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4656		.num_adc_nids = 1, /* single ADC */
4657		.hp_nid = 0x03,
4658		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4659		.channel_mode = alc880_2_jack_modes,
4660		.input_mux = &alc880_capture_source,
4661	},
4662	[ALC880_5ST] = {
4663		.mixers = { alc880_three_stack_mixer,
4664			    alc880_five_stack_mixer},
4665		.init_verbs = { alc880_volume_init_verbs,
4666				alc880_pin_5stack_init_verbs },
4667		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4668		.dac_nids = alc880_dac_nids,
4669		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4670		.channel_mode = alc880_fivestack_modes,
4671		.input_mux = &alc880_capture_source,
4672	},
4673	[ALC880_5ST_DIG] = {
4674		.mixers = { alc880_three_stack_mixer,
4675			    alc880_five_stack_mixer },
4676		.init_verbs = { alc880_volume_init_verbs,
4677				alc880_pin_5stack_init_verbs },
4678		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4679		.dac_nids = alc880_dac_nids,
4680		.dig_out_nid = ALC880_DIGOUT_NID,
4681		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4682		.channel_mode = alc880_fivestack_modes,
4683		.input_mux = &alc880_capture_source,
4684	},
4685	[ALC880_6ST] = {
4686		.mixers = { alc880_six_stack_mixer },
4687		.init_verbs = { alc880_volume_init_verbs,
4688				alc880_pin_6stack_init_verbs },
4689		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4690		.dac_nids = alc880_6st_dac_nids,
4691		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4692		.channel_mode = alc880_sixstack_modes,
4693		.input_mux = &alc880_6stack_capture_source,
4694	},
4695	[ALC880_6ST_DIG] = {
4696		.mixers = { alc880_six_stack_mixer },
4697		.init_verbs = { alc880_volume_init_verbs,
4698				alc880_pin_6stack_init_verbs },
4699		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4700		.dac_nids = alc880_6st_dac_nids,
4701		.dig_out_nid = ALC880_DIGOUT_NID,
4702		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4703		.channel_mode = alc880_sixstack_modes,
4704		.input_mux = &alc880_6stack_capture_source,
4705	},
4706	[ALC880_W810] = {
4707		.mixers = { alc880_w810_base_mixer },
4708		.init_verbs = { alc880_volume_init_verbs,
4709				alc880_pin_w810_init_verbs,
4710				alc880_gpio2_init_verbs },
4711		.num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4712		.dac_nids = alc880_w810_dac_nids,
4713		.dig_out_nid = ALC880_DIGOUT_NID,
4714		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4715		.channel_mode = alc880_w810_modes,
4716		.input_mux = &alc880_capture_source,
4717	},
4718	[ALC880_Z71V] = {
4719		.mixers = { alc880_z71v_mixer },
4720		.init_verbs = { alc880_volume_init_verbs,
4721				alc880_pin_z71v_init_verbs },
4722		.num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4723		.dac_nids = alc880_z71v_dac_nids,
4724		.dig_out_nid = ALC880_DIGOUT_NID,
4725		.hp_nid = 0x03,
4726		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4727		.channel_mode = alc880_2_jack_modes,
4728		.input_mux = &alc880_capture_source,
4729	},
4730	[ALC880_F1734] = {
4731		.mixers = { alc880_f1734_mixer },
4732		.init_verbs = { alc880_volume_init_verbs,
4733				alc880_pin_f1734_init_verbs },
4734		.num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4735		.dac_nids = alc880_f1734_dac_nids,
4736		.hp_nid = 0x02,
4737		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4738		.channel_mode = alc880_2_jack_modes,
4739		.input_mux = &alc880_f1734_capture_source,
4740		.unsol_event = alc880_uniwill_p53_unsol_event,
4741		.setup = alc880_uniwill_p53_setup,
4742		.init_hook = alc_automute_amp,
4743	},
4744	[ALC880_ASUS] = {
4745		.mixers = { alc880_asus_mixer },
4746		.init_verbs = { alc880_volume_init_verbs,
4747				alc880_pin_asus_init_verbs,
4748				alc880_gpio1_init_verbs },
4749		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4750		.dac_nids = alc880_asus_dac_nids,
4751		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4752		.channel_mode = alc880_asus_modes,
4753		.need_dac_fix = 1,
4754		.input_mux = &alc880_capture_source,
4755	},
4756	[ALC880_ASUS_DIG] = {
4757		.mixers = { alc880_asus_mixer },
4758		.init_verbs = { alc880_volume_init_verbs,
4759				alc880_pin_asus_init_verbs,
4760				alc880_gpio1_init_verbs },
4761		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4762		.dac_nids = alc880_asus_dac_nids,
4763		.dig_out_nid = ALC880_DIGOUT_NID,
4764		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4765		.channel_mode = alc880_asus_modes,
4766		.need_dac_fix = 1,
4767		.input_mux = &alc880_capture_source,
4768	},
4769	[ALC880_ASUS_DIG2] = {
4770		.mixers = { alc880_asus_mixer },
4771		.init_verbs = { alc880_volume_init_verbs,
4772				alc880_pin_asus_init_verbs,
4773				alc880_gpio2_init_verbs }, /* use GPIO2 */
4774		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4775		.dac_nids = alc880_asus_dac_nids,
4776		.dig_out_nid = ALC880_DIGOUT_NID,
4777		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4778		.channel_mode = alc880_asus_modes,
4779		.need_dac_fix = 1,
4780		.input_mux = &alc880_capture_source,
4781	},
4782	[ALC880_ASUS_W1V] = {
4783		.mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4784		.init_verbs = { alc880_volume_init_verbs,
4785				alc880_pin_asus_init_verbs,
4786				alc880_gpio1_init_verbs },
4787		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4788		.dac_nids = alc880_asus_dac_nids,
4789		.dig_out_nid = ALC880_DIGOUT_NID,
4790		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4791		.channel_mode = alc880_asus_modes,
4792		.need_dac_fix = 1,
4793		.input_mux = &alc880_capture_source,
4794	},
4795	[ALC880_UNIWILL_DIG] = {
4796		.mixers = { alc880_asus_mixer },
4797		.init_verbs = { alc880_volume_init_verbs,
4798				alc880_pin_asus_init_verbs },
4799		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4800		.dac_nids = alc880_asus_dac_nids,
4801		.dig_out_nid = ALC880_DIGOUT_NID,
4802		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4803		.channel_mode = alc880_asus_modes,
4804		.need_dac_fix = 1,
4805		.input_mux = &alc880_capture_source,
4806	},
4807	[ALC880_UNIWILL] = {
4808		.mixers = { alc880_uniwill_mixer },
4809		.init_verbs = { alc880_volume_init_verbs,
4810				alc880_uniwill_init_verbs },
4811		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4812		.dac_nids = alc880_asus_dac_nids,
4813		.dig_out_nid = ALC880_DIGOUT_NID,
4814		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4815		.channel_mode = alc880_threestack_modes,
4816		.need_dac_fix = 1,
4817		.input_mux = &alc880_capture_source,
4818		.unsol_event = alc880_uniwill_unsol_event,
4819		.setup = alc880_uniwill_setup,
4820		.init_hook = alc880_uniwill_init_hook,
4821	},
4822	[ALC880_UNIWILL_P53] = {
4823		.mixers = { alc880_uniwill_p53_mixer },
4824		.init_verbs = { alc880_volume_init_verbs,
4825				alc880_uniwill_p53_init_verbs },
4826		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4827		.dac_nids = alc880_asus_dac_nids,
4828		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4829		.channel_mode = alc880_threestack_modes,
4830		.input_mux = &alc880_capture_source,
4831		.unsol_event = alc880_uniwill_p53_unsol_event,
4832		.setup = alc880_uniwill_p53_setup,
4833		.init_hook = alc_automute_amp,
4834	},
4835	[ALC880_FUJITSU] = {
4836		.mixers = { alc880_fujitsu_mixer },
4837		.init_verbs = { alc880_volume_init_verbs,
4838				alc880_uniwill_p53_init_verbs,
4839	       			alc880_beep_init_verbs },
4840		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4841		.dac_nids = alc880_dac_nids,
4842		.dig_out_nid = ALC880_DIGOUT_NID,
4843		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4844		.channel_mode = alc880_2_jack_modes,
4845		.input_mux = &alc880_capture_source,
4846		.unsol_event = alc880_uniwill_p53_unsol_event,
4847		.setup = alc880_uniwill_p53_setup,
4848		.init_hook = alc_automute_amp,
4849	},
4850	[ALC880_CLEVO] = {
4851		.mixers = { alc880_three_stack_mixer },
4852		.init_verbs = { alc880_volume_init_verbs,
4853				alc880_pin_clevo_init_verbs },
4854		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4855		.dac_nids = alc880_dac_nids,
4856		.hp_nid = 0x03,
4857		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4858		.channel_mode = alc880_threestack_modes,
4859		.need_dac_fix = 1,
4860		.input_mux = &alc880_capture_source,
4861	},
4862	[ALC880_LG] = {
4863		.mixers = { alc880_lg_mixer },
4864		.init_verbs = { alc880_volume_init_verbs,
4865				alc880_lg_init_verbs },
4866		.num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4867		.dac_nids = alc880_lg_dac_nids,
4868		.dig_out_nid = ALC880_DIGOUT_NID,
4869		.num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4870		.channel_mode = alc880_lg_ch_modes,
4871		.need_dac_fix = 1,
4872		.input_mux = &alc880_lg_capture_source,
4873		.unsol_event = alc_automute_amp_unsol_event,
4874		.setup = alc880_lg_setup,
4875		.init_hook = alc_automute_amp,
4876#ifdef CONFIG_SND_HDA_POWER_SAVE
4877		.loopbacks = alc880_lg_loopbacks,
4878#endif
4879	},
4880	[ALC880_LG_LW] = {
4881		.mixers = { alc880_lg_lw_mixer },
4882		.init_verbs = { alc880_volume_init_verbs,
4883				alc880_lg_lw_init_verbs },
4884		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4885		.dac_nids = alc880_dac_nids,
4886		.dig_out_nid = ALC880_DIGOUT_NID,
4887		.num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4888		.channel_mode = alc880_lg_lw_modes,
4889		.input_mux = &alc880_lg_lw_capture_source,
4890		.unsol_event = alc_automute_amp_unsol_event,
4891		.setup = alc880_lg_lw_setup,
4892		.init_hook = alc_automute_amp,
4893	},
4894	[ALC880_MEDION_RIM] = {
4895		.mixers = { alc880_medion_rim_mixer },
4896		.init_verbs = { alc880_volume_init_verbs,
4897				alc880_medion_rim_init_verbs,
4898				alc_gpio2_init_verbs },
4899		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4900		.dac_nids = alc880_dac_nids,
4901		.dig_out_nid = ALC880_DIGOUT_NID,
4902		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4903		.channel_mode = alc880_2_jack_modes,
4904		.input_mux = &alc880_medion_rim_capture_source,
4905		.unsol_event = alc880_medion_rim_unsol_event,
4906		.setup = alc880_medion_rim_setup,
4907		.init_hook = alc880_medion_rim_automute,
4908	},
4909#ifdef CONFIG_SND_DEBUG
4910	[ALC880_TEST] = {
4911		.mixers = { alc880_test_mixer },
4912		.init_verbs = { alc880_test_init_verbs },
4913		.num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4914		.dac_nids = alc880_test_dac_nids,
4915		.dig_out_nid = ALC880_DIGOUT_NID,
4916		.num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4917		.channel_mode = alc880_test_modes,
4918		.input_mux = &alc880_test_capture_source,
4919	},
4920#endif
4921};
4922
4923/*
4924 * Automatic parse of I/O pins from the BIOS configuration
4925 */
4926
4927enum {
4928	ALC_CTL_WIDGET_VOL,
4929	ALC_CTL_WIDGET_MUTE,
4930	ALC_CTL_BIND_MUTE,
4931};
4932static struct snd_kcontrol_new alc880_control_templates[] = {
4933	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4934	HDA_CODEC_MUTE(NULL, 0, 0, 0),
4935	HDA_BIND_MUTE(NULL, 0, 0, 0),
4936};
4937
4938/* add dynamic controls */
4939static int add_control(struct alc_spec *spec, int type, const char *name,
4940		       int cidx, unsigned long val)
4941{
4942	struct snd_kcontrol_new *knew;
4943
4944	snd_array_init(&spec->kctls, sizeof(*knew), 32);
4945	knew = snd_array_new(&spec->kctls);
4946	if (!knew)
4947		return -ENOMEM;
4948	*knew = alc880_control_templates[type];
4949	knew->name = kstrdup(name, GFP_KERNEL);
4950	if (!knew->name)
4951		return -ENOMEM;
4952	knew->index = cidx;
4953	if (get_amp_nid_(val))
4954		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4955	knew->private_value = val;
4956	return 0;
4957}
4958
4959static int add_control_with_pfx(struct alc_spec *spec, int type,
4960				const char *pfx, const char *dir,
4961				const char *sfx, int cidx, unsigned long val)
4962{
4963	char name[32];
4964	snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4965	return add_control(spec, type, name, cidx, val);
4966}
4967
4968#define add_pb_vol_ctrl(spec, type, pfx, val)			\
4969	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
4970#define add_pb_sw_ctrl(spec, type, pfx, val)			\
4971	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
4972#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)			\
4973	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
4974#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)			\
4975	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
4976
4977#define alc880_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
4978#define alc880_fixed_pin_idx(nid)	((nid) - 0x14)
4979#define alc880_is_multi_pin(nid)	((nid) >= 0x18)
4980#define alc880_multi_pin_idx(nid)	((nid) - 0x18)
4981#define alc880_idx_to_dac(nid)		((nid) + 0x02)
4982#define alc880_dac_to_idx(nid)		((nid) - 0x02)
4983#define alc880_idx_to_mixer(nid)	((nid) + 0x0c)
4984#define alc880_idx_to_selector(nid)	((nid) + 0x10)
4985#define ALC880_PIN_CD_NID		0x1c
4986
4987/* fill in the dac_nids table from the parsed pin configuration */
4988static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4989				     const struct auto_pin_cfg *cfg)
4990{
4991	hda_nid_t nid;
4992	int assigned[4];
4993	int i, j;
4994
4995	memset(assigned, 0, sizeof(assigned));
4996	spec->multiout.dac_nids = spec->private_dac_nids;
4997
4998	/* check the pins hardwired to audio widget */
4999	for (i = 0; i < cfg->line_outs; i++) {
5000		nid = cfg->line_out_pins[i];
5001		if (alc880_is_fixed_pin(nid)) {
5002			int idx = alc880_fixed_pin_idx(nid);
5003			spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5004			assigned[idx] = 1;
5005		}
5006	}
5007	/* left pins can be connect to any audio widget */
5008	for (i = 0; i < cfg->line_outs; i++) {
5009		nid = cfg->line_out_pins[i];
5010		if (alc880_is_fixed_pin(nid))
5011			continue;
5012		/* search for an empty channel */
5013		for (j = 0; j < cfg->line_outs; j++) {
5014			if (!assigned[j]) {
5015				spec->multiout.dac_nids[i] =
5016					alc880_idx_to_dac(j);
5017				assigned[j] = 1;
5018				break;
5019			}
5020		}
5021	}
5022	spec->multiout.num_dacs = cfg->line_outs;
5023	return 0;
5024}
5025
5026/* add playback controls from the parsed DAC table */
5027static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5028					     const struct auto_pin_cfg *cfg)
5029{
5030	static const char *chname[4] = {
5031		"Front", "Surround", NULL /*CLFE*/, "Side"
5032	};
5033	hda_nid_t nid;
5034	int i, err;
5035
5036	for (i = 0; i < cfg->line_outs; i++) {
5037		if (!spec->multiout.dac_nids[i])
5038			continue;
5039		nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5040		if (i == 2) {
5041			/* Center/LFE */
5042			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5043					      "Center",
5044					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5045							      HDA_OUTPUT));
5046			if (err < 0)
5047				return err;
5048			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5049					      "LFE",
5050					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5051							      HDA_OUTPUT));
5052			if (err < 0)
5053				return err;
5054			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5055					     "Center",
5056					  HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5057							      HDA_INPUT));
5058			if (err < 0)
5059				return err;
5060			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5061					     "LFE",
5062					  HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5063							      HDA_INPUT));
5064			if (err < 0)
5065				return err;
5066		} else {
5067			const char *pfx;
5068			if (cfg->line_outs == 1 &&
5069			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
5070				pfx = "Speaker";
5071			else
5072				pfx = chname[i];
5073			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5074					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5075							      HDA_OUTPUT));
5076			if (err < 0)
5077				return err;
5078			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5079					  HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5080							      HDA_INPUT));
5081			if (err < 0)
5082				return err;
5083		}
5084	}
5085	return 0;
5086}
5087
5088/* add playback controls for speaker and HP outputs */
5089static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5090					const char *pfx)
5091{
5092	hda_nid_t nid;
5093	int err;
5094
5095	if (!pin)
5096		return 0;
5097
5098	if (alc880_is_fixed_pin(pin)) {
5099		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5100		/* specify the DAC as the extra output */
5101		if (!spec->multiout.hp_nid)
5102			spec->multiout.hp_nid = nid;
5103		else
5104			spec->multiout.extra_out_nid[0] = nid;
5105		/* control HP volume/switch on the output mixer amp */
5106		nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5107		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5108				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5109		if (err < 0)
5110			return err;
5111		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5112				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5113		if (err < 0)
5114			return err;
5115	} else if (alc880_is_multi_pin(pin)) {
5116		/* set manual connection */
5117		/* we have only a switch on HP-out PIN */
5118		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5119				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5120		if (err < 0)
5121			return err;
5122	}
5123	return 0;
5124}
5125
5126/* create input playback/capture controls for the given pin */
5127static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5128			    const char *ctlname, int ctlidx,
5129			    int idx, hda_nid_t mix_nid)
5130{
5131	int err;
5132
5133	err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5134			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5135	if (err < 0)
5136		return err;
5137	err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5138			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5139	if (err < 0)
5140		return err;
5141	return 0;
5142}
5143
5144static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5145{
5146	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5147	return (pincap & AC_PINCAP_IN) != 0;
5148}
5149
5150/* create playback/capture controls for input pins */
5151static int alc_auto_create_input_ctls(struct hda_codec *codec,
5152				      const struct auto_pin_cfg *cfg,
5153				      hda_nid_t mixer,
5154				      hda_nid_t cap1, hda_nid_t cap2)
5155{
5156	struct alc_spec *spec = codec->spec;
5157	struct hda_input_mux *imux = &spec->private_imux[0];
5158	int i, err, idx, type, type_idx = 0;
5159
5160	for (i = 0; i < cfg->num_inputs; i++) {
5161		hda_nid_t pin;
5162		const char *label;
5163
5164		pin = cfg->inputs[i].pin;
5165		if (!alc_is_input_pin(codec, pin))
5166			continue;
5167
5168		type = cfg->inputs[i].type;
5169		if (i > 0 && type == cfg->inputs[i - 1].type)
5170			type_idx++;
5171		else
5172			type_idx = 0;
5173		label = hda_get_autocfg_input_label(codec, cfg, i);
5174		if (mixer) {
5175			idx = get_connection_index(codec, mixer, pin);
5176			if (idx >= 0) {
5177				err = new_analog_input(spec, pin,
5178						       label, type_idx,
5179						       idx, mixer);
5180				if (err < 0)
5181					return err;
5182			}
5183		}
5184
5185		if (!cap1)
5186			continue;
5187		idx = get_connection_index(codec, cap1, pin);
5188		if (idx < 0 && cap2)
5189			idx = get_connection_index(codec, cap2, pin);
5190		if (idx >= 0)
5191			snd_hda_add_imux_item(imux, label, idx, NULL);
5192	}
5193	return 0;
5194}
5195
5196static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5197						const struct auto_pin_cfg *cfg)
5198{
5199	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5200}
5201
5202static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5203			       unsigned int pin_type)
5204{
5205	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5206			    pin_type);
5207	/* unmute pin */
5208	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5209			    AMP_OUT_UNMUTE);
5210}
5211
5212static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5213					      hda_nid_t nid, int pin_type,
5214					      int dac_idx)
5215{
5216	alc_set_pin_output(codec, nid, pin_type);
5217	/* need the manual connection? */
5218	if (alc880_is_multi_pin(nid)) {
5219		struct alc_spec *spec = codec->spec;
5220		int idx = alc880_multi_pin_idx(nid);
5221		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5222				    AC_VERB_SET_CONNECT_SEL,
5223				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5224	}
5225}
5226
5227static int get_pin_type(int line_out_type)
5228{
5229	if (line_out_type == AUTO_PIN_HP_OUT)
5230		return PIN_HP;
5231	else
5232		return PIN_OUT;
5233}
5234
5235static void alc880_auto_init_multi_out(struct hda_codec *codec)
5236{
5237	struct alc_spec *spec = codec->spec;
5238	int i;
5239
5240	for (i = 0; i < spec->autocfg.line_outs; i++) {
5241		hda_nid_t nid = spec->autocfg.line_out_pins[i];
5242		int pin_type = get_pin_type(spec->autocfg.line_out_type);
5243		alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5244	}
5245}
5246
5247static void alc880_auto_init_extra_out(struct hda_codec *codec)
5248{
5249	struct alc_spec *spec = codec->spec;
5250	hda_nid_t pin;
5251
5252	pin = spec->autocfg.speaker_pins[0];
5253	if (pin) /* connect to front */
5254		alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5255	pin = spec->autocfg.hp_pins[0];
5256	if (pin) /* connect to front */
5257		alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5258}
5259
5260static void alc880_auto_init_analog_input(struct hda_codec *codec)
5261{
5262	struct alc_spec *spec = codec->spec;
5263	struct auto_pin_cfg *cfg = &spec->autocfg;
5264	int i;
5265
5266	for (i = 0; i < cfg->num_inputs; i++) {
5267		hda_nid_t nid = cfg->inputs[i].pin;
5268		if (alc_is_input_pin(codec, nid)) {
5269			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5270			if (nid != ALC880_PIN_CD_NID &&
5271			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5272				snd_hda_codec_write(codec, nid, 0,
5273						    AC_VERB_SET_AMP_GAIN_MUTE,
5274						    AMP_OUT_MUTE);
5275		}
5276	}
5277}
5278
5279static void alc880_auto_init_input_src(struct hda_codec *codec)
5280{
5281	struct alc_spec *spec = codec->spec;
5282	int c;
5283
5284	for (c = 0; c < spec->num_adc_nids; c++) {
5285		unsigned int mux_idx;
5286		const struct hda_input_mux *imux;
5287		mux_idx = c >= spec->num_mux_defs ? 0 : c;
5288		imux = &spec->input_mux[mux_idx];
5289		if (!imux->num_items && mux_idx > 0)
5290			imux = &spec->input_mux[0];
5291		if (imux)
5292			snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5293					    AC_VERB_SET_CONNECT_SEL,
5294					    imux->items[0].index);
5295	}
5296}
5297
5298/* parse the BIOS configuration and set up the alc_spec */
5299/* return 1 if successful, 0 if the proper config is not found,
5300 * or a negative error code
5301 */
5302static int alc880_parse_auto_config(struct hda_codec *codec)
5303{
5304	struct alc_spec *spec = codec->spec;
5305	int err;
5306	static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5307
5308	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5309					   alc880_ignore);
5310	if (err < 0)
5311		return err;
5312	if (!spec->autocfg.line_outs)
5313		return 0; /* can't find valid BIOS pin config */
5314
5315	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5316	if (err < 0)
5317		return err;
5318	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5319	if (err < 0)
5320		return err;
5321	err = alc880_auto_create_extra_out(spec,
5322					   spec->autocfg.speaker_pins[0],
5323					   "Speaker");
5324	if (err < 0)
5325		return err;
5326	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5327					   "Headphone");
5328	if (err < 0)
5329		return err;
5330	err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5331	if (err < 0)
5332		return err;
5333
5334	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5335
5336	alc_auto_parse_digital(codec);
5337
5338	if (spec->kctls.list)
5339		add_mixer(spec, spec->kctls.list);
5340
5341	add_verb(spec, alc880_volume_init_verbs);
5342
5343	spec->num_mux_defs = 1;
5344	spec->input_mux = &spec->private_imux[0];
5345
5346	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5347
5348	return 1;
5349}
5350
5351/* additional initialization for auto-configuration model */
5352static void alc880_auto_init(struct hda_codec *codec)
5353{
5354	struct alc_spec *spec = codec->spec;
5355	alc880_auto_init_multi_out(codec);
5356	alc880_auto_init_extra_out(codec);
5357	alc880_auto_init_analog_input(codec);
5358	alc880_auto_init_input_src(codec);
5359	alc_auto_init_digital(codec);
5360	if (spec->unsol_event)
5361		alc_inithook(codec);
5362}
5363
5364/* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5365 * one of two digital mic pins, e.g. on ALC272
5366 */
5367static void fixup_automic_adc(struct hda_codec *codec)
5368{
5369	struct alc_spec *spec = codec->spec;
5370	int i;
5371
5372	for (i = 0; i < spec->num_adc_nids; i++) {
5373		hda_nid_t cap = spec->capsrc_nids ?
5374			spec->capsrc_nids[i] : spec->adc_nids[i];
5375		int iidx, eidx;
5376
5377		iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5378		if (iidx < 0)
5379			continue;
5380		eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5381		if (eidx < 0)
5382			continue;
5383		spec->int_mic.mux_idx = iidx;
5384		spec->ext_mic.mux_idx = eidx;
5385		if (spec->capsrc_nids)
5386			spec->capsrc_nids += i;
5387		spec->adc_nids += i;
5388		spec->num_adc_nids = 1;
5389		return;
5390	}
5391	snd_printd(KERN_INFO "hda_codec: %s: "
5392		   "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5393		   codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5394	spec->auto_mic = 0; /* disable auto-mic to be sure */
5395}
5396
5397/* select or unmute the given capsrc route */
5398static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5399				    int idx)
5400{
5401	if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5402		snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5403					 HDA_AMP_MUTE, 0);
5404	} else {
5405		snd_hda_codec_write_cache(codec, cap, 0,
5406					  AC_VERB_SET_CONNECT_SEL, idx);
5407	}
5408}
5409
5410/* set the default connection to that pin */
5411static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5412{
5413	struct alc_spec *spec = codec->spec;
5414	int i;
5415
5416	for (i = 0; i < spec->num_adc_nids; i++) {
5417		hda_nid_t cap = spec->capsrc_nids ?
5418			spec->capsrc_nids[i] : spec->adc_nids[i];
5419		int idx;
5420
5421		idx = get_connection_index(codec, cap, pin);
5422		if (idx < 0)
5423			continue;
5424		select_or_unmute_capsrc(codec, cap, idx);
5425		return i; /* return the found index */
5426	}
5427	return -1; /* not found */
5428}
5429
5430/* choose the ADC/MUX containing the input pin and initialize the setup */
5431static void fixup_single_adc(struct hda_codec *codec)
5432{
5433	struct alc_spec *spec = codec->spec;
5434	struct auto_pin_cfg *cfg = &spec->autocfg;
5435	int i;
5436
5437	/* search for the input pin; there must be only one */
5438	if (cfg->num_inputs != 1)
5439		return;
5440	i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5441	if (i >= 0) {
5442		/* use only this ADC */
5443		if (spec->capsrc_nids)
5444			spec->capsrc_nids += i;
5445		spec->adc_nids += i;
5446		spec->num_adc_nids = 1;
5447	}
5448}
5449
5450/* initialize dual adcs */
5451static void fixup_dual_adc_switch(struct hda_codec *codec)
5452{
5453	struct alc_spec *spec = codec->spec;
5454	init_capsrc_for_pin(codec, spec->ext_mic.pin);
5455	init_capsrc_for_pin(codec, spec->int_mic.pin);
5456}
5457
5458static void set_capture_mixer(struct hda_codec *codec)
5459{
5460	struct alc_spec *spec = codec->spec;
5461	static struct snd_kcontrol_new *caps[2][3] = {
5462		{ alc_capture_mixer_nosrc1,
5463		  alc_capture_mixer_nosrc2,
5464		  alc_capture_mixer_nosrc3 },
5465		{ alc_capture_mixer1,
5466		  alc_capture_mixer2,
5467		  alc_capture_mixer3 },
5468	};
5469	if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5470		int mux = 0;
5471		int num_adcs = spec->num_adc_nids;
5472		if (spec->dual_adc_switch)
5473			fixup_dual_adc_switch(codec);
5474		else if (spec->auto_mic)
5475			fixup_automic_adc(codec);
5476		else if (spec->input_mux) {
5477			if (spec->input_mux->num_items > 1)
5478				mux = 1;
5479			else if (spec->input_mux->num_items == 1)
5480				fixup_single_adc(codec);
5481		}
5482		if (spec->dual_adc_switch)
5483			num_adcs = 1;
5484		spec->cap_mixer = caps[mux][num_adcs - 1];
5485	}
5486}
5487
5488/* fill adc_nids (and capsrc_nids) containing all active input pins */
5489static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5490				 int num_nids)
5491{
5492	struct alc_spec *spec = codec->spec;
5493	struct auto_pin_cfg *cfg = &spec->autocfg;
5494	int n;
5495	hda_nid_t fallback_adc = 0, fallback_cap = 0;
5496
5497	for (n = 0; n < num_nids; n++) {
5498		hda_nid_t adc, cap;
5499		hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5500		int nconns, i, j;
5501
5502		adc = nids[n];
5503		if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5504			continue;
5505		cap = adc;
5506		nconns = snd_hda_get_connections(codec, cap, conn,
5507						 ARRAY_SIZE(conn));
5508		if (nconns == 1) {
5509			cap = conn[0];
5510			nconns = snd_hda_get_connections(codec, cap, conn,
5511							 ARRAY_SIZE(conn));
5512		}
5513		if (nconns <= 0)
5514			continue;
5515		if (!fallback_adc) {
5516			fallback_adc = adc;
5517			fallback_cap = cap;
5518		}
5519		for (i = 0; i < cfg->num_inputs; i++) {
5520			hda_nid_t nid = cfg->inputs[i].pin;
5521			for (j = 0; j < nconns; j++) {
5522				if (conn[j] == nid)
5523					break;
5524			}
5525			if (j >= nconns)
5526				break;
5527		}
5528		if (i >= cfg->num_inputs) {
5529			int num_adcs = spec->num_adc_nids;
5530			spec->private_adc_nids[num_adcs] = adc;
5531			spec->private_capsrc_nids[num_adcs] = cap;
5532			spec->num_adc_nids++;
5533			spec->adc_nids = spec->private_adc_nids;
5534			if (adc != cap)
5535				spec->capsrc_nids = spec->private_capsrc_nids;
5536		}
5537	}
5538	if (!spec->num_adc_nids) {
5539		printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5540		       " using fallback 0x%x\n",
5541		       codec->chip_name, fallback_adc);
5542		spec->private_adc_nids[0] = fallback_adc;
5543		spec->adc_nids = spec->private_adc_nids;
5544		if (fallback_adc != fallback_cap) {
5545			spec->private_capsrc_nids[0] = fallback_cap;
5546			spec->capsrc_nids = spec->private_adc_nids;
5547		}
5548	}
5549}
5550
5551#ifdef CONFIG_SND_HDA_INPUT_BEEP
5552#define set_beep_amp(spec, nid, idx, dir) \
5553	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5554
5555static struct snd_pci_quirk beep_white_list[] = {
5556	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5557	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5558	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5559	{}
5560};
5561
5562static inline int has_cdefine_beep(struct hda_codec *codec)
5563{
5564	struct alc_spec *spec = codec->spec;
5565	const struct snd_pci_quirk *q;
5566	q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5567	if (q)
5568		return q->value;
5569	return spec->cdefine.enable_pcbeep;
5570}
5571#else
5572#define set_beep_amp(spec, nid, idx, dir) /* NOP */
5573#define has_cdefine_beep(codec)		0
5574#endif
5575
5576/*
5577 * OK, here we have finally the patch for ALC880
5578 */
5579
5580static int patch_alc880(struct hda_codec *codec)
5581{
5582	struct alc_spec *spec;
5583	int board_config;
5584	int err;
5585
5586	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5587	if (spec == NULL)
5588		return -ENOMEM;
5589
5590	codec->spec = spec;
5591
5592	board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5593						  alc880_models,
5594						  alc880_cfg_tbl);
5595	if (board_config < 0) {
5596		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5597		       codec->chip_name);
5598		board_config = ALC880_AUTO;
5599	}
5600
5601	if (board_config == ALC880_AUTO) {
5602		/* automatic parse from the BIOS config */
5603		err = alc880_parse_auto_config(codec);
5604		if (err < 0) {
5605			alc_free(codec);
5606			return err;
5607		} else if (!err) {
5608			printk(KERN_INFO
5609			       "hda_codec: Cannot set up configuration "
5610			       "from BIOS.  Using 3-stack mode...\n");
5611			board_config = ALC880_3ST;
5612		}
5613	}
5614
5615	err = snd_hda_attach_beep_device(codec, 0x1);
5616	if (err < 0) {
5617		alc_free(codec);
5618		return err;
5619	}
5620
5621	if (board_config != ALC880_AUTO)
5622		setup_preset(codec, &alc880_presets[board_config]);
5623
5624	spec->stream_analog_playback = &alc880_pcm_analog_playback;
5625	spec->stream_analog_capture = &alc880_pcm_analog_capture;
5626	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5627
5628	spec->stream_digital_playback = &alc880_pcm_digital_playback;
5629	spec->stream_digital_capture = &alc880_pcm_digital_capture;
5630
5631	if (!spec->adc_nids && spec->input_mux) {
5632		/* check whether NID 0x07 is valid */
5633		unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5634		/* get type */
5635		wcap = get_wcaps_type(wcap);
5636		if (wcap != AC_WID_AUD_IN) {
5637			spec->adc_nids = alc880_adc_nids_alt;
5638			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5639		} else {
5640			spec->adc_nids = alc880_adc_nids;
5641			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5642		}
5643	}
5644	set_capture_mixer(codec);
5645	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5646
5647	spec->vmaster_nid = 0x0c;
5648
5649	codec->patch_ops = alc_patch_ops;
5650	if (board_config == ALC880_AUTO)
5651		spec->init_hook = alc880_auto_init;
5652#ifdef CONFIG_SND_HDA_POWER_SAVE
5653	if (!spec->loopback.amplist)
5654		spec->loopback.amplist = alc880_loopbacks;
5655#endif
5656
5657	return 0;
5658}
5659
5660
5661/*
5662 * ALC260 support
5663 */
5664
5665static hda_nid_t alc260_dac_nids[1] = {
5666	/* front */
5667	0x02,
5668};
5669
5670static hda_nid_t alc260_adc_nids[1] = {
5671	/* ADC0 */
5672	0x04,
5673};
5674
5675static hda_nid_t alc260_adc_nids_alt[1] = {
5676	/* ADC1 */
5677	0x05,
5678};
5679
5680/* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5681 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5682 */
5683static hda_nid_t alc260_dual_adc_nids[2] = {
5684	/* ADC0, ADC1 */
5685	0x04, 0x05
5686};
5687
5688#define ALC260_DIGOUT_NID	0x03
5689#define ALC260_DIGIN_NID	0x06
5690
5691static struct hda_input_mux alc260_capture_source = {
5692	.num_items = 4,
5693	.items = {
5694		{ "Mic", 0x0 },
5695		{ "Front Mic", 0x1 },
5696		{ "Line", 0x2 },
5697		{ "CD", 0x4 },
5698	},
5699};
5700
5701/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5702 * headphone jack and the internal CD lines since these are the only pins at
5703 * which audio can appear.  For flexibility, also allow the option of
5704 * recording the mixer output on the second ADC (ADC0 doesn't have a
5705 * connection to the mixer output).
5706 */
5707static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5708	{
5709		.num_items = 3,
5710		.items = {
5711			{ "Mic/Line", 0x0 },
5712			{ "CD", 0x4 },
5713			{ "Headphone", 0x2 },
5714		},
5715	},
5716	{
5717		.num_items = 4,
5718		.items = {
5719			{ "Mic/Line", 0x0 },
5720			{ "CD", 0x4 },
5721			{ "Headphone", 0x2 },
5722			{ "Mixer", 0x5 },
5723		},
5724	},
5725
5726};
5727
5728/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5729 * the Fujitsu S702x, but jacks are marked differently.
5730 */
5731static struct hda_input_mux alc260_acer_capture_sources[2] = {
5732	{
5733		.num_items = 4,
5734		.items = {
5735			{ "Mic", 0x0 },
5736			{ "Line", 0x2 },
5737			{ "CD", 0x4 },
5738			{ "Headphone", 0x5 },
5739		},
5740	},
5741	{
5742		.num_items = 5,
5743		.items = {
5744			{ "Mic", 0x0 },
5745			{ "Line", 0x2 },
5746			{ "CD", 0x4 },
5747			{ "Headphone", 0x6 },
5748			{ "Mixer", 0x5 },
5749		},
5750	},
5751};
5752
5753/* Maxdata Favorit 100XS */
5754static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5755	{
5756		.num_items = 2,
5757		.items = {
5758			{ "Line/Mic", 0x0 },
5759			{ "CD", 0x4 },
5760		},
5761	},
5762	{
5763		.num_items = 3,
5764		.items = {
5765			{ "Line/Mic", 0x0 },
5766			{ "CD", 0x4 },
5767			{ "Mixer", 0x5 },
5768		},
5769	},
5770};
5771
5772/*
5773 * This is just place-holder, so there's something for alc_build_pcms to look
5774 * at when it calculates the maximum number of channels. ALC260 has no mixer
5775 * element which allows changing the channel mode, so the verb list is
5776 * never used.
5777 */
5778static struct hda_channel_mode alc260_modes[1] = {
5779	{ 2, NULL },
5780};
5781
5782
5783/* Mixer combinations
5784 *
5785 * basic: base_output + input + pc_beep + capture
5786 * HP: base_output + input + capture_alt
5787 * HP_3013: hp_3013 + input + capture
5788 * fujitsu: fujitsu + capture
5789 * acer: acer + capture
5790 */
5791
5792static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5793	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5794	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5795	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5796	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5797	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5798	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5799	{ } /* end */
5800};
5801
5802static struct snd_kcontrol_new alc260_input_mixer[] = {
5803	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5804	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5805	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5806	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5807	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5808	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5809	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5810	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5811	{ } /* end */
5812};
5813
5814/* update HP, line and mono out pins according to the master switch */
5815static void alc260_hp_master_update(struct hda_codec *codec,
5816				    hda_nid_t hp, hda_nid_t line,
5817				    hda_nid_t mono)
5818{
5819	struct alc_spec *spec = codec->spec;
5820	unsigned int val = spec->master_sw ? PIN_HP : 0;
5821	/* change HP and line-out pins */
5822	snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5823			    val);
5824	snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5825			    val);
5826	/* mono (speaker) depending on the HP jack sense */
5827	val = (val && !spec->jack_present) ? PIN_OUT : 0;
5828	snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5829			    val);
5830}
5831
5832static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5833				   struct snd_ctl_elem_value *ucontrol)
5834{
5835	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5836	struct alc_spec *spec = codec->spec;
5837	*ucontrol->value.integer.value = spec->master_sw;
5838	return 0;
5839}
5840
5841static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5842				   struct snd_ctl_elem_value *ucontrol)
5843{
5844	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5845	struct alc_spec *spec = codec->spec;
5846	int val = !!*ucontrol->value.integer.value;
5847	hda_nid_t hp, line, mono;
5848
5849	if (val == spec->master_sw)
5850		return 0;
5851	spec->master_sw = val;
5852	hp = (kcontrol->private_value >> 16) & 0xff;
5853	line = (kcontrol->private_value >> 8) & 0xff;
5854	mono = kcontrol->private_value & 0xff;
5855	alc260_hp_master_update(codec, hp, line, mono);
5856	return 1;
5857}
5858
5859static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5860	{
5861		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5862		.name = "Master Playback Switch",
5863		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5864		.info = snd_ctl_boolean_mono_info,
5865		.get = alc260_hp_master_sw_get,
5866		.put = alc260_hp_master_sw_put,
5867		.private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5868	},
5869	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5870	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5871	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5872	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5873	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5874			      HDA_OUTPUT),
5875	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5876	{ } /* end */
5877};
5878
5879static struct hda_verb alc260_hp_unsol_verbs[] = {
5880	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5881	{},
5882};
5883
5884static void alc260_hp_automute(struct hda_codec *codec)
5885{
5886	struct alc_spec *spec = codec->spec;
5887
5888	spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5889	alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5890}
5891
5892static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5893{
5894	if ((res >> 26) == ALC880_HP_EVENT)
5895		alc260_hp_automute(codec);
5896}
5897
5898static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5899	{
5900		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5901		.name = "Master Playback Switch",
5902		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5903		.info = snd_ctl_boolean_mono_info,
5904		.get = alc260_hp_master_sw_get,
5905		.put = alc260_hp_master_sw_put,
5906		.private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5907	},
5908	HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5909	HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5910	HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5911	HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5912	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5913	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5914	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5915	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5916	{ } /* end */
5917};
5918
5919static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5920	.ops = &snd_hda_bind_vol,
5921	.values = {
5922		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5923		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5924		HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5925		0
5926	},
5927};
5928
5929static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5930	.ops = &snd_hda_bind_sw,
5931	.values = {
5932		HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5933		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5934		0
5935	},
5936};
5937
5938static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5939	HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5940	HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5941	HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5942	HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5943	{ } /* end */
5944};
5945
5946static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5947	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5948	{},
5949};
5950
5951static void alc260_hp_3013_automute(struct hda_codec *codec)
5952{
5953	struct alc_spec *spec = codec->spec;
5954
5955	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5956	alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5957}
5958
5959static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5960				       unsigned int res)
5961{
5962	if ((res >> 26) == ALC880_HP_EVENT)
5963		alc260_hp_3013_automute(codec);
5964}
5965
5966static void alc260_hp_3012_automute(struct hda_codec *codec)
5967{
5968	unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5969
5970	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5971			    bits);
5972	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5973			    bits);
5974	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5975			    bits);
5976}
5977
5978static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5979				       unsigned int res)
5980{
5981	if ((res >> 26) == ALC880_HP_EVENT)
5982		alc260_hp_3012_automute(codec);
5983}
5984
5985/* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5986 * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5987 */
5988static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5989	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5990	HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5991	ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5992	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5993	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5994	HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5995	HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5996	ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5997	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5998	HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5999	{ } /* end */
6000};
6001
6002/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6003 * versions of the ALC260 don't act on requests to enable mic bias from NID
6004 * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6005 * datasheet doesn't mention this restriction.  At this stage it's not clear
6006 * whether this behaviour is intentional or is a hardware bug in chip
6007 * revisions available in early 2006.  Therefore for now allow the
6008 * "Headphone Jack Mode" control to span all choices, but if it turns out
6009 * that the lack of mic bias for this NID is intentional we could change the
6010 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6011 *
6012 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6013 * don't appear to make the mic bias available from the "line" jack, even
6014 * though the NID used for this jack (0x14) can supply it.  The theory is
6015 * that perhaps Acer have included blocking capacitors between the ALC260
6016 * and the output jack.  If this turns out to be the case for all such
6017 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6018 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6019 *
6020 * The C20x Tablet series have a mono internal speaker which is controlled
6021 * via the chip's Mono sum widget and pin complex, so include the necessary
6022 * controls for such models.  On models without a "mono speaker" the control
6023 * won't do anything.
6024 */
6025static struct snd_kcontrol_new alc260_acer_mixer[] = {
6026	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6027	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6028	ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6029	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6030			      HDA_OUTPUT),
6031	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6032			   HDA_INPUT),
6033	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6034	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6035	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6036	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6037	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6038	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6039	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6040	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6041	{ } /* end */
6042};
6043
6044/* Maxdata Favorit 100XS: one output and one input (0x12) jack
6045 */
6046static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6047	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6048	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6049	ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6050	HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6051	HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6052	ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6053	{ } /* end */
6054};
6055
6056/* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6057 * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6058 */
6059static struct snd_kcontrol_new alc260_will_mixer[] = {
6060	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6061	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6062	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6063	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6064	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6065	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6066	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6067	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6068	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6069	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6070	{ } /* end */
6071};
6072
6073/* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6074 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6075 */
6076static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6077	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6078	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6079	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6080	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6081	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6082	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6083	HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6084	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6085	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6086	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6087	{ } /* end */
6088};
6089
6090/*
6091 * initialization verbs
6092 */
6093static struct hda_verb alc260_init_verbs[] = {
6094	/* Line In pin widget for input */
6095	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6096	/* CD pin widget for input */
6097	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6098	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6099	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6100	/* Mic2 (front panel) pin widget for input and vref at 80% */
6101	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6102	/* LINE-2 is used for line-out in rear */
6103	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6104	/* select line-out */
6105	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6106	/* LINE-OUT pin */
6107	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6108	/* enable HP */
6109	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6110	/* enable Mono */
6111	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6112	/* mute capture amp left and right */
6113	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6114	/* set connection select to line in (default select for this ADC) */
6115	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6116	/* mute capture amp left and right */
6117	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6118	/* set connection select to line in (default select for this ADC) */
6119	{0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6120	/* set vol=0 Line-Out mixer amp left and right */
6121	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6122	/* unmute pin widget amp left and right (no gain on this amp) */
6123	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6124	/* set vol=0 HP mixer amp left and right */
6125	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6126	/* unmute pin widget amp left and right (no gain on this amp) */
6127	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6128	/* set vol=0 Mono mixer amp left and right */
6129	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6130	/* unmute pin widget amp left and right (no gain on this amp) */
6131	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6132	/* unmute LINE-2 out pin */
6133	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6134	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6135	 * Line In 2 = 0x03
6136	 */
6137	/* mute analog inputs */
6138	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6139	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6140	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6141	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6142	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6143	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6144	/* mute Front out path */
6145	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6146	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6147	/* mute Headphone out path */
6148	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6149	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6150	/* mute Mono out path */
6151	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6152	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6153	{ }
6154};
6155
6156#if 0 /* should be identical with alc260_init_verbs? */
6157static struct hda_verb alc260_hp_init_verbs[] = {
6158	/* Headphone and output */
6159	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6160	/* mono output */
6161	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6162	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6163	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6164	/* Mic2 (front panel) pin widget for input and vref at 80% */
6165	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6166	/* Line In pin widget for input */
6167	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6168	/* Line-2 pin widget for output */
6169	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6170	/* CD pin widget for input */
6171	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6172	/* unmute amp left and right */
6173	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6174	/* set connection select to line in (default select for this ADC) */
6175	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6176	/* unmute Line-Out mixer amp left and right (volume = 0) */
6177	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6178	/* mute pin widget amp left and right (no gain on this amp) */
6179	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6180	/* unmute HP mixer amp left and right (volume = 0) */
6181	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6182	/* mute pin widget amp left and right (no gain on this amp) */
6183	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6184	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6185	 * Line In 2 = 0x03
6186	 */
6187	/* mute analog inputs */
6188	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6189	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6190	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6191	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6192	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6193	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6194	/* Unmute Front out path */
6195	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6196	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6197	/* Unmute Headphone out path */
6198	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6199	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6200	/* Unmute Mono out path */
6201	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6202	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6203	{ }
6204};
6205#endif
6206
6207static struct hda_verb alc260_hp_3013_init_verbs[] = {
6208	/* Line out and output */
6209	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6210	/* mono output */
6211	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6212	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6213	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6214	/* Mic2 (front panel) pin widget for input and vref at 80% */
6215	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6216	/* Line In pin widget for input */
6217	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6218	/* Headphone pin widget for output */
6219	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6220	/* CD pin widget for input */
6221	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6222	/* unmute amp left and right */
6223	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6224	/* set connection select to line in (default select for this ADC) */
6225	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6226	/* unmute Line-Out mixer amp left and right (volume = 0) */
6227	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6228	/* mute pin widget amp left and right (no gain on this amp) */
6229	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6230	/* unmute HP mixer amp left and right (volume = 0) */
6231	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6232	/* mute pin widget amp left and right (no gain on this amp) */
6233	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6234	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6235	 * Line In 2 = 0x03
6236	 */
6237	/* mute analog inputs */
6238	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6239	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6240	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6241	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6242	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6243	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6244	/* Unmute Front out path */
6245	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6246	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6247	/* Unmute Headphone out path */
6248	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6249	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6250	/* Unmute Mono out path */
6251	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6252	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6253	{ }
6254};
6255
6256/* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6257 * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6258 * audio = 0x16, internal speaker = 0x10.
6259 */
6260static struct hda_verb alc260_fujitsu_init_verbs[] = {
6261	/* Disable all GPIOs */
6262	{0x01, AC_VERB_SET_GPIO_MASK, 0},
6263	/* Internal speaker is connected to headphone pin */
6264	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6265	/* Headphone/Line-out jack connects to Line1 pin; make it an output */
6266	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6267	/* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6268	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6269	/* Ensure all other unused pins are disabled and muted. */
6270	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6271	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6272	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6273	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6274	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6275	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6276	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6277	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6278
6279	/* Disable digital (SPDIF) pins */
6280	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6281	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6282
6283	/* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6284	 * when acting as an output.
6285	 */
6286	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6287
6288	/* Start with output sum widgets muted and their output gains at min */
6289	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6290	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6291	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6292	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6293	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6294	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6295	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6296	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6297	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6298
6299	/* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6300	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6301	/* Unmute Line1 pin widget output buffer since it starts as an output.
6302	 * If the pin mode is changed by the user the pin mode control will
6303	 * take care of enabling the pin's input/output buffers as needed.
6304	 * Therefore there's no need to enable the input buffer at this
6305	 * stage.
6306	 */
6307	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6308	/* Unmute input buffer of pin widget used for Line-in (no equiv
6309	 * mixer ctrl)
6310	 */
6311	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6312
6313	/* Mute capture amp left and right */
6314	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6315	/* Set ADC connection select to match default mixer setting - line
6316	 * in (on mic1 pin)
6317	 */
6318	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6319
6320	/* Do the same for the second ADC: mute capture input amp and
6321	 * set ADC connection to line in (on mic1 pin)
6322	 */
6323	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6324	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6325
6326	/* Mute all inputs to mixer widget (even unconnected ones) */
6327	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6328	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6329	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6330	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6331	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6332	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6333	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6334	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6335
6336	{ }
6337};
6338
6339/* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6340 * similar laptops (adapted from Fujitsu init verbs).
6341 */
6342static struct hda_verb alc260_acer_init_verbs[] = {
6343	/* On TravelMate laptops, GPIO 0 enables the internal speaker and
6344	 * the headphone jack.  Turn this on and rely on the standard mute
6345	 * methods whenever the user wants to turn these outputs off.
6346	 */
6347	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6348	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6349	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6350	/* Internal speaker/Headphone jack is connected to Line-out pin */
6351	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6352	/* Internal microphone/Mic jack is connected to Mic1 pin */
6353	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6354	/* Line In jack is connected to Line1 pin */
6355	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6356	/* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6357	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6358	/* Ensure all other unused pins are disabled and muted. */
6359	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6360	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6361	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6362	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6363	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6364	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6365	/* Disable digital (SPDIF) pins */
6366	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6367	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6368
6369	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6370	 * bus when acting as outputs.
6371	 */
6372	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6373	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6374
6375	/* Start with output sum widgets muted and their output gains at min */
6376	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6377	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6378	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6379	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6380	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6381	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6382	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6383	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6384	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6385
6386	/* Unmute Line-out pin widget amp left and right
6387	 * (no equiv mixer ctrl)
6388	 */
6389	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6390	/* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6391	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6392	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
6393	 * inputs. If the pin mode is changed by the user the pin mode control
6394	 * will take care of enabling the pin's input/output buffers as needed.
6395	 * Therefore there's no need to enable the input buffer at this
6396	 * stage.
6397	 */
6398	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6399	{0x14, 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
6427/* Initialisation sequence for Maxdata Favorit 100XS
6428 * (adapted from Acer init verbs).
6429 */
6430static struct hda_verb alc260_favorit100_init_verbs[] = {
6431	/* GPIO 0 enables the output jack.
6432	 * Turn this on and rely on the standard mute
6433	 * methods whenever the user wants to turn these outputs off.
6434	 */
6435	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6436	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6437	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6438	/* Line/Mic input jack is connected to Mic1 pin */
6439	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6440	/* Ensure all other unused pins are disabled and muted. */
6441	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6442	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6443	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6444	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6445	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6446	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6447	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6448	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6449	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6450	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6451	/* Disable digital (SPDIF) pins */
6452	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6453	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6454
6455	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6456	 * bus when acting as outputs.
6457	 */
6458	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6459	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6460
6461	/* Start with output sum widgets muted and their output gains at min */
6462	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6463	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6464	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6465	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6466	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6467	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6468	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6469	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6470	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6471
6472	/* Unmute Line-out pin widget amp left and right
6473	 * (no equiv mixer ctrl)
6474	 */
6475	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6476	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
6477	 * inputs. If the pin mode is changed by the user the pin mode control
6478	 * will take care of enabling the pin's input/output buffers as needed.
6479	 * Therefore there's no need to enable the input buffer at this
6480	 * stage.
6481	 */
6482	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6483
6484	/* Mute capture amp left and right */
6485	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6486	/* Set ADC connection select to match default mixer setting - mic
6487	 * (on mic1 pin)
6488	 */
6489	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6490
6491	/* Do similar with the second ADC: mute capture input amp and
6492	 * set ADC connection to mic to match ALSA's default state.
6493	 */
6494	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6495	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6496
6497	/* Mute all inputs to mixer widget (even unconnected ones) */
6498	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6499	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6500	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6501	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6502	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6503	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6504	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6505	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6506
6507	{ }
6508};
6509
6510static struct hda_verb alc260_will_verbs[] = {
6511	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6512	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6513	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6514	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6515	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6516	{0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6517	{}
6518};
6519
6520static struct hda_verb alc260_replacer_672v_verbs[] = {
6521	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6522	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6523	{0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6524
6525	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6526	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6527	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6528
6529	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6530	{}
6531};
6532
6533/* toggle speaker-output according to the hp-jack state */
6534static void alc260_replacer_672v_automute(struct hda_codec *codec)
6535{
6536        unsigned int present;
6537
6538	/* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6539	present = snd_hda_jack_detect(codec, 0x0f);
6540	if (present) {
6541		snd_hda_codec_write_cache(codec, 0x01, 0,
6542					  AC_VERB_SET_GPIO_DATA, 1);
6543		snd_hda_codec_write_cache(codec, 0x0f, 0,
6544					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6545					  PIN_HP);
6546	} else {
6547		snd_hda_codec_write_cache(codec, 0x01, 0,
6548					  AC_VERB_SET_GPIO_DATA, 0);
6549		snd_hda_codec_write_cache(codec, 0x0f, 0,
6550					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6551					  PIN_OUT);
6552	}
6553}
6554
6555static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6556                                       unsigned int res)
6557{
6558        if ((res >> 26) == ALC880_HP_EVENT)
6559                alc260_replacer_672v_automute(codec);
6560}
6561
6562static struct hda_verb alc260_hp_dc7600_verbs[] = {
6563	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6564	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6565	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6566	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6567	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6568	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6569	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6570	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6571	{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6572	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6573	{}
6574};
6575
6576/* Test configuration for debugging, modelled after the ALC880 test
6577 * configuration.
6578 */
6579#ifdef CONFIG_SND_DEBUG
6580static hda_nid_t alc260_test_dac_nids[1] = {
6581	0x02,
6582};
6583static hda_nid_t alc260_test_adc_nids[2] = {
6584	0x04, 0x05,
6585};
6586/* For testing the ALC260, each input MUX needs its own definition since
6587 * the signal assignments are different.  This assumes that the first ADC
6588 * is NID 0x04.
6589 */
6590static struct hda_input_mux alc260_test_capture_sources[2] = {
6591	{
6592		.num_items = 7,
6593		.items = {
6594			{ "MIC1 pin", 0x0 },
6595			{ "MIC2 pin", 0x1 },
6596			{ "LINE1 pin", 0x2 },
6597			{ "LINE2 pin", 0x3 },
6598			{ "CD pin", 0x4 },
6599			{ "LINE-OUT pin", 0x5 },
6600			{ "HP-OUT pin", 0x6 },
6601		},
6602        },
6603	{
6604		.num_items = 8,
6605		.items = {
6606			{ "MIC1 pin", 0x0 },
6607			{ "MIC2 pin", 0x1 },
6608			{ "LINE1 pin", 0x2 },
6609			{ "LINE2 pin", 0x3 },
6610			{ "CD pin", 0x4 },
6611			{ "Mixer", 0x5 },
6612			{ "LINE-OUT pin", 0x6 },
6613			{ "HP-OUT pin", 0x7 },
6614		},
6615        },
6616};
6617static struct snd_kcontrol_new alc260_test_mixer[] = {
6618	/* Output driver widgets */
6619	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6620	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6621	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6622	HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6623	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6624	HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6625
6626	/* Modes for retasking pin widgets
6627	 * Note: the ALC260 doesn't seem to act on requests to enable mic
6628         * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6629         * mention this restriction.  At this stage it's not clear whether
6630         * this behaviour is intentional or is a hardware bug in chip
6631         * revisions available at least up until early 2006.  Therefore for
6632         * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6633         * choices, but if it turns out that the lack of mic bias for these
6634         * NIDs is intentional we could change their modes from
6635         * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6636	 */
6637	ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6638	ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6639	ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6640	ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6641	ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6642	ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6643
6644	/* Loopback mixer controls */
6645	HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6646	HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6647	HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6648	HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6649	HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6650	HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6651	HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6652	HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6653	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6654	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6655	HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6656	HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6657	HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6658	HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6659
6660	/* Controls for GPIO pins, assuming they are configured as outputs */
6661	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6662	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6663	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6664	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6665
6666	/* Switches to allow the digital IO pins to be enabled.  The datasheet
6667	 * is ambigious as to which NID is which; testing on laptops which
6668	 * make this output available should provide clarification.
6669	 */
6670	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6671	ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6672
6673	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
6674	 * this output to turn on an external amplifier.
6675	 */
6676	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6677	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6678
6679	{ } /* end */
6680};
6681static struct hda_verb alc260_test_init_verbs[] = {
6682	/* Enable all GPIOs as outputs with an initial value of 0 */
6683	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6684	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6685	{0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6686
6687	/* Enable retasking pins as output, initially without power amp */
6688	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6689	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6690	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6691	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6692	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6693	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6694
6695	/* Disable digital (SPDIF) pins initially, but users can enable
6696	 * them via a mixer switch.  In the case of SPDIF-out, this initverb
6697	 * payload also sets the generation to 0, output to be in "consumer"
6698	 * PCM format, copyright asserted, no pre-emphasis and no validity
6699	 * control.
6700	 */
6701	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6702	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6703
6704	/* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6705	 * OUT1 sum bus when acting as an output.
6706	 */
6707	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6708	{0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6709	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6710	{0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6711
6712	/* Start with output sum widgets muted and their output gains at min */
6713	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6714	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6715	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6716	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6717	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6718	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6719	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6720	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6721	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6722
6723	/* Unmute retasking pin widget output buffers since the default
6724	 * state appears to be output.  As the pin mode is changed by the
6725	 * user the pin mode control will take care of enabling the pin's
6726	 * input/output buffers as needed.
6727	 */
6728	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6729	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6730	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6731	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6732	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6733	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6734	/* Also unmute the mono-out pin widget */
6735	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6736
6737	/* Mute capture amp left and right */
6738	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6739	/* Set ADC connection select to match default mixer setting (mic1
6740	 * pin)
6741	 */
6742	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6743
6744	/* Do the same for the second ADC: mute capture input amp and
6745	 * set ADC connection to mic1 pin
6746	 */
6747	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6748	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6749
6750	/* Mute all inputs to mixer widget (even unconnected ones) */
6751	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6752	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6753	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6754	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6755	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6756	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6757	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6758	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6759
6760	{ }
6761};
6762#endif
6763
6764#define alc260_pcm_analog_playback	alc880_pcm_analog_alt_playback
6765#define alc260_pcm_analog_capture	alc880_pcm_analog_capture
6766
6767#define alc260_pcm_digital_playback	alc880_pcm_digital_playback
6768#define alc260_pcm_digital_capture	alc880_pcm_digital_capture
6769
6770/*
6771 * for BIOS auto-configuration
6772 */
6773
6774static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6775					const char *pfx, int *vol_bits)
6776{
6777	hda_nid_t nid_vol;
6778	unsigned long vol_val, sw_val;
6779	int err;
6780
6781	if (nid >= 0x0f && nid < 0x11) {
6782		nid_vol = nid - 0x7;
6783		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6784		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6785	} else if (nid == 0x11) {
6786		nid_vol = nid - 0x7;
6787		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6788		sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6789	} else if (nid >= 0x12 && nid <= 0x15) {
6790		nid_vol = 0x08;
6791		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6792		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6793	} else
6794		return 0; /* N/A */
6795
6796	if (!(*vol_bits & (1 << nid_vol))) {
6797		/* first control for the volume widget */
6798		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6799		if (err < 0)
6800			return err;
6801		*vol_bits |= (1 << nid_vol);
6802	}
6803	err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6804	if (err < 0)
6805		return err;
6806	return 1;
6807}
6808
6809/* add playback controls from the parsed DAC table */
6810static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6811					     const struct auto_pin_cfg *cfg)
6812{
6813	hda_nid_t nid;
6814	int err;
6815	int vols = 0;
6816
6817	spec->multiout.num_dacs = 1;
6818	spec->multiout.dac_nids = spec->private_dac_nids;
6819	spec->multiout.dac_nids[0] = 0x02;
6820
6821	nid = cfg->line_out_pins[0];
6822	if (nid) {
6823		const char *pfx;
6824		if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6825			pfx = "Master";
6826		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6827			pfx = "Speaker";
6828		else
6829			pfx = "Front";
6830		err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6831		if (err < 0)
6832			return err;
6833	}
6834
6835	nid = cfg->speaker_pins[0];
6836	if (nid) {
6837		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6838		if (err < 0)
6839			return err;
6840	}
6841
6842	nid = cfg->hp_pins[0];
6843	if (nid) {
6844		err = alc260_add_playback_controls(spec, nid, "Headphone",
6845						   &vols);
6846		if (err < 0)
6847			return err;
6848	}
6849	return 0;
6850}
6851
6852/* create playback/capture controls for input pins */
6853static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6854						const struct auto_pin_cfg *cfg)
6855{
6856	return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6857}
6858
6859static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6860					      hda_nid_t nid, int pin_type,
6861					      int sel_idx)
6862{
6863	alc_set_pin_output(codec, nid, pin_type);
6864	/* need the manual connection? */
6865	if (nid >= 0x12) {
6866		int idx = nid - 0x12;
6867		snd_hda_codec_write(codec, idx + 0x0b, 0,
6868				    AC_VERB_SET_CONNECT_SEL, sel_idx);
6869	}
6870}
6871
6872static void alc260_auto_init_multi_out(struct hda_codec *codec)
6873{
6874	struct alc_spec *spec = codec->spec;
6875	hda_nid_t nid;
6876
6877	nid = spec->autocfg.line_out_pins[0];
6878	if (nid) {
6879		int pin_type = get_pin_type(spec->autocfg.line_out_type);
6880		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6881	}
6882
6883	nid = spec->autocfg.speaker_pins[0];
6884	if (nid)
6885		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6886
6887	nid = spec->autocfg.hp_pins[0];
6888	if (nid)
6889		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6890}
6891
6892#define ALC260_PIN_CD_NID		0x16
6893static void alc260_auto_init_analog_input(struct hda_codec *codec)
6894{
6895	struct alc_spec *spec = codec->spec;
6896	struct auto_pin_cfg *cfg = &spec->autocfg;
6897	int i;
6898
6899	for (i = 0; i < cfg->num_inputs; i++) {
6900		hda_nid_t nid = cfg->inputs[i].pin;
6901		if (nid >= 0x12) {
6902			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6903			if (nid != ALC260_PIN_CD_NID &&
6904			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6905				snd_hda_codec_write(codec, nid, 0,
6906						    AC_VERB_SET_AMP_GAIN_MUTE,
6907						    AMP_OUT_MUTE);
6908		}
6909	}
6910}
6911
6912#define alc260_auto_init_input_src	alc880_auto_init_input_src
6913
6914/*
6915 * generic initialization of ADC, input mixers and output mixers
6916 */
6917static struct hda_verb alc260_volume_init_verbs[] = {
6918	/*
6919	 * Unmute ADC0-1 and set the default input to mic-in
6920	 */
6921	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6922	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6923	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6924	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6925
6926	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6927	 * mixer widget
6928	 * Note: PASD motherboards uses the Line In 2 as the input for
6929	 * front panel mic (mic 2)
6930	 */
6931	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6932	/* mute analog inputs */
6933	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6934	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6935	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6936	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6937	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6938
6939	/*
6940	 * Set up output mixers (0x08 - 0x0a)
6941	 */
6942	/* set vol=0 to output mixers */
6943	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6944	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6945	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6946	/* set up input amps for analog loopback */
6947	/* Amp Indices: DAC = 0, mixer = 1 */
6948	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6949	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6950	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6951	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6952	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6953	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6954
6955	{ }
6956};
6957
6958static int alc260_parse_auto_config(struct hda_codec *codec)
6959{
6960	struct alc_spec *spec = codec->spec;
6961	int err;
6962	static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6963
6964	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6965					   alc260_ignore);
6966	if (err < 0)
6967		return err;
6968	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6969	if (err < 0)
6970		return err;
6971	if (!spec->kctls.list)
6972		return 0; /* can't find valid BIOS pin config */
6973	err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6974	if (err < 0)
6975		return err;
6976
6977	spec->multiout.max_channels = 2;
6978
6979	if (spec->autocfg.dig_outs)
6980		spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6981	if (spec->kctls.list)
6982		add_mixer(spec, spec->kctls.list);
6983
6984	add_verb(spec, alc260_volume_init_verbs);
6985
6986	spec->num_mux_defs = 1;
6987	spec->input_mux = &spec->private_imux[0];
6988
6989	alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6990
6991	return 1;
6992}
6993
6994/* additional initialization for auto-configuration model */
6995static void alc260_auto_init(struct hda_codec *codec)
6996{
6997	struct alc_spec *spec = codec->spec;
6998	alc260_auto_init_multi_out(codec);
6999	alc260_auto_init_analog_input(codec);
7000	alc260_auto_init_input_src(codec);
7001	alc_auto_init_digital(codec);
7002	if (spec->unsol_event)
7003		alc_inithook(codec);
7004}
7005
7006#ifdef CONFIG_SND_HDA_POWER_SAVE
7007static struct hda_amp_list alc260_loopbacks[] = {
7008	{ 0x07, HDA_INPUT, 0 },
7009	{ 0x07, HDA_INPUT, 1 },
7010	{ 0x07, HDA_INPUT, 2 },
7011	{ 0x07, HDA_INPUT, 3 },
7012	{ 0x07, HDA_INPUT, 4 },
7013	{ } /* end */
7014};
7015#endif
7016
7017/*
7018 * Pin config fixes
7019 */
7020enum {
7021	PINFIX_HP_DC5750,
7022};
7023
7024static const struct alc_fixup alc260_fixups[] = {
7025	[PINFIX_HP_DC5750] = {
7026		.pins = (const struct alc_pincfg[]) {
7027			{ 0x11, 0x90130110 }, /* speaker */
7028			{ }
7029		}
7030	},
7031};
7032
7033static struct snd_pci_quirk alc260_fixup_tbl[] = {
7034	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7035	{}
7036};
7037
7038/*
7039 * ALC260 configurations
7040 */
7041static const char *alc260_models[ALC260_MODEL_LAST] = {
7042	[ALC260_BASIC]		= "basic",
7043	[ALC260_HP]		= "hp",
7044	[ALC260_HP_3013]	= "hp-3013",
7045	[ALC260_HP_DC7600]	= "hp-dc7600",
7046	[ALC260_FUJITSU_S702X]	= "fujitsu",
7047	[ALC260_ACER]		= "acer",
7048	[ALC260_WILL]		= "will",
7049	[ALC260_REPLACER_672V]	= "replacer",
7050	[ALC260_FAVORIT100]	= "favorit100",
7051#ifdef CONFIG_SND_DEBUG
7052	[ALC260_TEST]		= "test",
7053#endif
7054	[ALC260_AUTO]		= "auto",
7055};
7056
7057static struct snd_pci_quirk alc260_cfg_tbl[] = {
7058	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7059	SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7060	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7061	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7062	SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7063	SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7064	SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7065	SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7066	SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7067	SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7068	SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7069	SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7070	SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7071	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7072	SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7073	SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7074	SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7075	SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7076	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7077	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7078	{}
7079};
7080
7081static struct alc_config_preset alc260_presets[] = {
7082	[ALC260_BASIC] = {
7083		.mixers = { alc260_base_output_mixer,
7084			    alc260_input_mixer },
7085		.init_verbs = { alc260_init_verbs },
7086		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7087		.dac_nids = alc260_dac_nids,
7088		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7089		.adc_nids = alc260_dual_adc_nids,
7090		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7091		.channel_mode = alc260_modes,
7092		.input_mux = &alc260_capture_source,
7093	},
7094	[ALC260_HP] = {
7095		.mixers = { alc260_hp_output_mixer,
7096			    alc260_input_mixer },
7097		.init_verbs = { alc260_init_verbs,
7098				alc260_hp_unsol_verbs },
7099		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7100		.dac_nids = alc260_dac_nids,
7101		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7102		.adc_nids = alc260_adc_nids_alt,
7103		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7104		.channel_mode = alc260_modes,
7105		.input_mux = &alc260_capture_source,
7106		.unsol_event = alc260_hp_unsol_event,
7107		.init_hook = alc260_hp_automute,
7108	},
7109	[ALC260_HP_DC7600] = {
7110		.mixers = { alc260_hp_dc7600_mixer,
7111			    alc260_input_mixer },
7112		.init_verbs = { alc260_init_verbs,
7113				alc260_hp_dc7600_verbs },
7114		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7115		.dac_nids = alc260_dac_nids,
7116		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7117		.adc_nids = alc260_adc_nids_alt,
7118		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7119		.channel_mode = alc260_modes,
7120		.input_mux = &alc260_capture_source,
7121		.unsol_event = alc260_hp_3012_unsol_event,
7122		.init_hook = alc260_hp_3012_automute,
7123	},
7124	[ALC260_HP_3013] = {
7125		.mixers = { alc260_hp_3013_mixer,
7126			    alc260_input_mixer },
7127		.init_verbs = { alc260_hp_3013_init_verbs,
7128				alc260_hp_3013_unsol_verbs },
7129		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7130		.dac_nids = alc260_dac_nids,
7131		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7132		.adc_nids = alc260_adc_nids_alt,
7133		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7134		.channel_mode = alc260_modes,
7135		.input_mux = &alc260_capture_source,
7136		.unsol_event = alc260_hp_3013_unsol_event,
7137		.init_hook = alc260_hp_3013_automute,
7138	},
7139	[ALC260_FUJITSU_S702X] = {
7140		.mixers = { alc260_fujitsu_mixer },
7141		.init_verbs = { alc260_fujitsu_init_verbs },
7142		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7143		.dac_nids = alc260_dac_nids,
7144		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7145		.adc_nids = alc260_dual_adc_nids,
7146		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7147		.channel_mode = alc260_modes,
7148		.num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7149		.input_mux = alc260_fujitsu_capture_sources,
7150	},
7151	[ALC260_ACER] = {
7152		.mixers = { alc260_acer_mixer },
7153		.init_verbs = { alc260_acer_init_verbs },
7154		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7155		.dac_nids = alc260_dac_nids,
7156		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7157		.adc_nids = alc260_dual_adc_nids,
7158		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7159		.channel_mode = alc260_modes,
7160		.num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7161		.input_mux = alc260_acer_capture_sources,
7162	},
7163	[ALC260_FAVORIT100] = {
7164		.mixers = { alc260_favorit100_mixer },
7165		.init_verbs = { alc260_favorit100_init_verbs },
7166		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7167		.dac_nids = alc260_dac_nids,
7168		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7169		.adc_nids = alc260_dual_adc_nids,
7170		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7171		.channel_mode = alc260_modes,
7172		.num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7173		.input_mux = alc260_favorit100_capture_sources,
7174	},
7175	[ALC260_WILL] = {
7176		.mixers = { alc260_will_mixer },
7177		.init_verbs = { alc260_init_verbs, alc260_will_verbs },
7178		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7179		.dac_nids = alc260_dac_nids,
7180		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7181		.adc_nids = alc260_adc_nids,
7182		.dig_out_nid = ALC260_DIGOUT_NID,
7183		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7184		.channel_mode = alc260_modes,
7185		.input_mux = &alc260_capture_source,
7186	},
7187	[ALC260_REPLACER_672V] = {
7188		.mixers = { alc260_replacer_672v_mixer },
7189		.init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7190		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7191		.dac_nids = alc260_dac_nids,
7192		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7193		.adc_nids = alc260_adc_nids,
7194		.dig_out_nid = ALC260_DIGOUT_NID,
7195		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7196		.channel_mode = alc260_modes,
7197		.input_mux = &alc260_capture_source,
7198		.unsol_event = alc260_replacer_672v_unsol_event,
7199		.init_hook = alc260_replacer_672v_automute,
7200	},
7201#ifdef CONFIG_SND_DEBUG
7202	[ALC260_TEST] = {
7203		.mixers = { alc260_test_mixer },
7204		.init_verbs = { alc260_test_init_verbs },
7205		.num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7206		.dac_nids = alc260_test_dac_nids,
7207		.num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7208		.adc_nids = alc260_test_adc_nids,
7209		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7210		.channel_mode = alc260_modes,
7211		.num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7212		.input_mux = alc260_test_capture_sources,
7213	},
7214#endif
7215};
7216
7217static int patch_alc260(struct hda_codec *codec)
7218{
7219	struct alc_spec *spec;
7220	int err, board_config;
7221
7222	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7223	if (spec == NULL)
7224		return -ENOMEM;
7225
7226	codec->spec = spec;
7227
7228	board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7229						  alc260_models,
7230						  alc260_cfg_tbl);
7231	if (board_config < 0) {
7232		snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7233			   codec->chip_name);
7234		board_config = ALC260_AUTO;
7235	}
7236
7237	if (board_config == ALC260_AUTO)
7238		alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7239
7240	if (board_config == ALC260_AUTO) {
7241		/* automatic parse from the BIOS config */
7242		err = alc260_parse_auto_config(codec);
7243		if (err < 0) {
7244			alc_free(codec);
7245			return err;
7246		} else if (!err) {
7247			printk(KERN_INFO
7248			       "hda_codec: Cannot set up configuration "
7249			       "from BIOS.  Using base mode...\n");
7250			board_config = ALC260_BASIC;
7251		}
7252	}
7253
7254	err = snd_hda_attach_beep_device(codec, 0x1);
7255	if (err < 0) {
7256		alc_free(codec);
7257		return err;
7258	}
7259
7260	if (board_config != ALC260_AUTO)
7261		setup_preset(codec, &alc260_presets[board_config]);
7262
7263	spec->stream_analog_playback = &alc260_pcm_analog_playback;
7264	spec->stream_analog_capture = &alc260_pcm_analog_capture;
7265	spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7266
7267	spec->stream_digital_playback = &alc260_pcm_digital_playback;
7268	spec->stream_digital_capture = &alc260_pcm_digital_capture;
7269
7270	if (!spec->adc_nids && spec->input_mux) {
7271		/* check whether NID 0x04 is valid */
7272		unsigned int wcap = get_wcaps(codec, 0x04);
7273		wcap = get_wcaps_type(wcap);
7274		/* get type */
7275		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7276			spec->adc_nids = alc260_adc_nids_alt;
7277			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7278		} else {
7279			spec->adc_nids = alc260_adc_nids;
7280			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7281		}
7282	}
7283	set_capture_mixer(codec);
7284	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7285
7286	if (board_config == ALC260_AUTO)
7287		alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7288
7289	spec->vmaster_nid = 0x08;
7290
7291	codec->patch_ops = alc_patch_ops;
7292	if (board_config == ALC260_AUTO)
7293		spec->init_hook = alc260_auto_init;
7294#ifdef CONFIG_SND_HDA_POWER_SAVE
7295	if (!spec->loopback.amplist)
7296		spec->loopback.amplist = alc260_loopbacks;
7297#endif
7298
7299	return 0;
7300}
7301
7302
7303/*
7304 * ALC882/883/885/888/889 support
7305 *
7306 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7307 * configuration.  Each pin widget can choose any input DACs and a mixer.
7308 * Each ADC is connected from a mixer of all inputs.  This makes possible
7309 * 6-channel independent captures.
7310 *
7311 * In addition, an independent DAC for the multi-playback (not used in this
7312 * driver yet).
7313 */
7314#define ALC882_DIGOUT_NID	0x06
7315#define ALC882_DIGIN_NID	0x0a
7316#define ALC883_DIGOUT_NID	ALC882_DIGOUT_NID
7317#define ALC883_DIGIN_NID	ALC882_DIGIN_NID
7318#define ALC1200_DIGOUT_NID	0x10
7319
7320
7321static struct hda_channel_mode alc882_ch_modes[1] = {
7322	{ 8, NULL }
7323};
7324
7325/* DACs */
7326static hda_nid_t alc882_dac_nids[4] = {
7327	/* front, rear, clfe, rear_surr */
7328	0x02, 0x03, 0x04, 0x05
7329};
7330#define alc883_dac_nids		alc882_dac_nids
7331
7332/* ADCs */
7333#define alc882_adc_nids		alc880_adc_nids
7334#define alc882_adc_nids_alt	alc880_adc_nids_alt
7335#define alc883_adc_nids		alc882_adc_nids_alt
7336static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7337static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7338#define alc889_adc_nids		alc880_adc_nids
7339
7340static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7341static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7342#define alc883_capsrc_nids	alc882_capsrc_nids_alt
7343static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7344#define alc889_capsrc_nids	alc882_capsrc_nids
7345
7346/* input MUX */
7347/* FIXME: should be a matrix-type input source selection */
7348
7349static struct hda_input_mux alc882_capture_source = {
7350	.num_items = 4,
7351	.items = {
7352		{ "Mic", 0x0 },
7353		{ "Front Mic", 0x1 },
7354		{ "Line", 0x2 },
7355		{ "CD", 0x4 },
7356	},
7357};
7358
7359#define alc883_capture_source	alc882_capture_source
7360
7361static struct hda_input_mux alc889_capture_source = {
7362	.num_items = 3,
7363	.items = {
7364		{ "Front Mic", 0x0 },
7365		{ "Mic", 0x3 },
7366		{ "Line", 0x2 },
7367	},
7368};
7369
7370static struct hda_input_mux mb5_capture_source = {
7371	.num_items = 3,
7372	.items = {
7373		{ "Mic", 0x1 },
7374		{ "Line", 0x7 },
7375		{ "CD", 0x4 },
7376	},
7377};
7378
7379static struct hda_input_mux macmini3_capture_source = {
7380	.num_items = 2,
7381	.items = {
7382		{ "Line", 0x2 },
7383		{ "CD", 0x4 },
7384	},
7385};
7386
7387static struct hda_input_mux alc883_3stack_6ch_intel = {
7388	.num_items = 4,
7389	.items = {
7390		{ "Mic", 0x1 },
7391		{ "Front Mic", 0x0 },
7392		{ "Line", 0x2 },
7393		{ "CD", 0x4 },
7394	},
7395};
7396
7397static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7398	.num_items = 2,
7399	.items = {
7400		{ "Mic", 0x1 },
7401		{ "Line", 0x2 },
7402	},
7403};
7404
7405static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7406	.num_items = 4,
7407	.items = {
7408		{ "Mic", 0x0 },
7409		{ "Int Mic", 0x1 },
7410		{ "Line", 0x2 },
7411		{ "CD", 0x4 },
7412	},
7413};
7414
7415static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7416	.num_items = 2,
7417	.items = {
7418		{ "Mic", 0x0 },
7419		{ "Int Mic", 0x1 },
7420	},
7421};
7422
7423static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7424	.num_items = 3,
7425	.items = {
7426		{ "Mic", 0x0 },
7427		{ "Front Mic", 0x1 },
7428		{ "Line", 0x4 },
7429	},
7430};
7431
7432static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7433	.num_items = 2,
7434	.items = {
7435		{ "Mic", 0x0 },
7436		{ "Line", 0x2 },
7437	},
7438};
7439
7440static struct hda_input_mux alc889A_mb31_capture_source = {
7441	.num_items = 2,
7442	.items = {
7443		{ "Mic", 0x0 },
7444		/* Front Mic (0x01) unused */
7445		{ "Line", 0x2 },
7446		/* Line 2 (0x03) unused */
7447		/* CD (0x04) unused? */
7448	},
7449};
7450
7451static struct hda_input_mux alc889A_imac91_capture_source = {
7452	.num_items = 2,
7453	.items = {
7454		{ "Mic", 0x01 },
7455		{ "Line", 0x2 }, /* Not sure! */
7456	},
7457};
7458
7459/*
7460 * 2ch mode
7461 */
7462static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7463	{ 2, NULL }
7464};
7465
7466/*
7467 * 2ch mode
7468 */
7469static struct hda_verb alc882_3ST_ch2_init[] = {
7470	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7471	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7472	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7473	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7474	{ } /* end */
7475};
7476
7477/*
7478 * 4ch mode
7479 */
7480static struct hda_verb alc882_3ST_ch4_init[] = {
7481	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7482	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7483	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7484	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7485	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7486	{ } /* end */
7487};
7488
7489/*
7490 * 6ch mode
7491 */
7492static struct hda_verb alc882_3ST_ch6_init[] = {
7493	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7494	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7495	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7496	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7497	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7498	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7499	{ } /* end */
7500};
7501
7502static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7503	{ 2, alc882_3ST_ch2_init },
7504	{ 4, alc882_3ST_ch4_init },
7505	{ 6, alc882_3ST_ch6_init },
7506};
7507
7508#define alc883_3ST_6ch_modes	alc882_3ST_6ch_modes
7509
7510/*
7511 * 2ch mode
7512 */
7513static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7514	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7515	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7516	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7517	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7518	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7519	{ } /* end */
7520};
7521
7522/*
7523 * 4ch mode
7524 */
7525static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7526	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7527	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7528	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7529	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7530	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7531	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7532	{ } /* end */
7533};
7534
7535/*
7536 * 6ch mode
7537 */
7538static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7539	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7540	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7541	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7542	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7543	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7544	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7545	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7546	{ } /* end */
7547};
7548
7549static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7550	{ 2, alc883_3ST_ch2_clevo_init },
7551	{ 4, alc883_3ST_ch4_clevo_init },
7552	{ 6, alc883_3ST_ch6_clevo_init },
7553};
7554
7555
7556/*
7557 * 6ch mode
7558 */
7559static struct hda_verb alc882_sixstack_ch6_init[] = {
7560	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7561	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7562	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7563	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7564	{ } /* end */
7565};
7566
7567/*
7568 * 8ch mode
7569 */
7570static struct hda_verb alc882_sixstack_ch8_init[] = {
7571	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7572	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7573	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7574	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7575	{ } /* end */
7576};
7577
7578static struct hda_channel_mode alc882_sixstack_modes[2] = {
7579	{ 6, alc882_sixstack_ch6_init },
7580	{ 8, alc882_sixstack_ch8_init },
7581};
7582
7583
7584/* Macbook Air 2,1 */
7585
7586static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7587      { 2, NULL },
7588};
7589
7590/*
7591 * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7592 */
7593
7594/*
7595 * 2ch mode
7596 */
7597static struct hda_verb alc885_mbp_ch2_init[] = {
7598	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7599	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7600	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7601	{ } /* end */
7602};
7603
7604/*
7605 * 4ch mode
7606 */
7607static struct hda_verb alc885_mbp_ch4_init[] = {
7608	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7609	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7610	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7611	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7612	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7613	{ } /* end */
7614};
7615
7616static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7617	{ 2, alc885_mbp_ch2_init },
7618	{ 4, alc885_mbp_ch4_init },
7619};
7620
7621/*
7622 * 2ch
7623 * Speakers/Woofer/HP = Front
7624 * LineIn = Input
7625 */
7626static struct hda_verb alc885_mb5_ch2_init[] = {
7627	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7628	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7629	{ } /* end */
7630};
7631
7632/*
7633 * 6ch mode
7634 * Speakers/HP = Front
7635 * Woofer = LFE
7636 * LineIn = Surround
7637 */
7638static struct hda_verb alc885_mb5_ch6_init[] = {
7639	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7640	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7641	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7642	{ } /* end */
7643};
7644
7645static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7646	{ 2, alc885_mb5_ch2_init },
7647	{ 6, alc885_mb5_ch6_init },
7648};
7649
7650#define alc885_macmini3_6ch_modes	alc885_mb5_6ch_modes
7651
7652/*
7653 * 2ch mode
7654 */
7655static struct hda_verb alc883_4ST_ch2_init[] = {
7656	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7657	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7658	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7659	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7660	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7661	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7662	{ } /* end */
7663};
7664
7665/*
7666 * 4ch mode
7667 */
7668static struct hda_verb alc883_4ST_ch4_init[] = {
7669	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7670	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7671	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7672	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7673	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7674	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7675	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7676	{ } /* end */
7677};
7678
7679/*
7680 * 6ch mode
7681 */
7682static struct hda_verb alc883_4ST_ch6_init[] = {
7683	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7684	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7685	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7686	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7687	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7688	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7689	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7690	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7691	{ } /* end */
7692};
7693
7694/*
7695 * 8ch mode
7696 */
7697static struct hda_verb alc883_4ST_ch8_init[] = {
7698	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7699	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7700	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7701	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7702	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7703	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7704	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7705	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7706	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7707	{ } /* end */
7708};
7709
7710static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7711	{ 2, alc883_4ST_ch2_init },
7712	{ 4, alc883_4ST_ch4_init },
7713	{ 6, alc883_4ST_ch6_init },
7714	{ 8, alc883_4ST_ch8_init },
7715};
7716
7717
7718/*
7719 * 2ch mode
7720 */
7721static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7722	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7723	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7724	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7725	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7726	{ } /* end */
7727};
7728
7729/*
7730 * 4ch mode
7731 */
7732static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7733	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7734	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7735	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7736	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7737	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7738	{ } /* end */
7739};
7740
7741/*
7742 * 6ch mode
7743 */
7744static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7745	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7746	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7747	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7748	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7749	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7750	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7751	{ } /* end */
7752};
7753
7754static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7755	{ 2, alc883_3ST_ch2_intel_init },
7756	{ 4, alc883_3ST_ch4_intel_init },
7757	{ 6, alc883_3ST_ch6_intel_init },
7758};
7759
7760/*
7761 * 2ch mode
7762 */
7763static struct hda_verb alc889_ch2_intel_init[] = {
7764	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7765	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7766	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7767	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7768	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7769	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7770	{ } /* end */
7771};
7772
7773/*
7774 * 6ch mode
7775 */
7776static struct hda_verb alc889_ch6_intel_init[] = {
7777	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7778	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7779	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7780	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7781	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7782	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7783	{ } /* end */
7784};
7785
7786/*
7787 * 8ch mode
7788 */
7789static struct hda_verb alc889_ch8_intel_init[] = {
7790	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7791	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7792	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7793	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7794	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7795	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7796	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7797	{ } /* end */
7798};
7799
7800static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7801	{ 2, alc889_ch2_intel_init },
7802	{ 6, alc889_ch6_intel_init },
7803	{ 8, alc889_ch8_intel_init },
7804};
7805
7806/*
7807 * 6ch mode
7808 */
7809static struct hda_verb alc883_sixstack_ch6_init[] = {
7810	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7811	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7812	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7813	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7814	{ } /* end */
7815};
7816
7817/*
7818 * 8ch mode
7819 */
7820static struct hda_verb alc883_sixstack_ch8_init[] = {
7821	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7822	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7823	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7824	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7825	{ } /* end */
7826};
7827
7828static struct hda_channel_mode alc883_sixstack_modes[2] = {
7829	{ 6, alc883_sixstack_ch6_init },
7830	{ 8, alc883_sixstack_ch8_init },
7831};
7832
7833
7834/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7835 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7836 */
7837static struct snd_kcontrol_new alc882_base_mixer[] = {
7838	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7839	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7840	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7841	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7842	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7843	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7844	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7845	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7846	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7847	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7848	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7849	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7850	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7851	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7852	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7853	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7854	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7855	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7856	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7857	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7858	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7859	{ } /* end */
7860};
7861
7862/* Macbook Air 2,1 same control for HP and internal Speaker */
7863
7864static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7865      HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7866      HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7867     { }
7868};
7869
7870
7871static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7872	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7873	HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7874	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7875	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7876	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7877	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7878	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7879	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7880	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7881	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7882	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7883	{ } /* end */
7884};
7885
7886static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7887	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7888	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7889	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7890	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7891	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7892	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7893	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7894	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7895	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7896	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7897	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7898	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7899	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7900	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7901	{ } /* end */
7902};
7903
7904static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7905	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7906	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7907	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7908	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7909	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7910	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7911	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7912	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7913	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7914	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7915	HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7916	{ } /* end */
7917};
7918
7919static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7920	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7921	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7922	{ } /* end */
7923};
7924
7925
7926static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7927	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7928	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7929	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7930	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7931	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7932	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7933	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7934	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7935	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7936	{ } /* end */
7937};
7938
7939static struct snd_kcontrol_new alc882_targa_mixer[] = {
7940	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7941	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7942	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7943	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7944	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7945	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7946	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7947	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7948	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7949	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7950	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7951	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7952	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7953	{ } /* end */
7954};
7955
7956/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7957 *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7958 */
7959static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7960	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7961	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7962	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7963	HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7964	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7965	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7966	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7967	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7968	HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7969	HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7970	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7971	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7972	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7973	{ } /* end */
7974};
7975
7976static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7977	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7978	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7979	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7980	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7981	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7982	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7983	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7984	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7985	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7986	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7987	{ } /* end */
7988};
7989
7990static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7991	{
7992		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7993		.name = "Channel Mode",
7994		.info = alc_ch_mode_info,
7995		.get = alc_ch_mode_get,
7996		.put = alc_ch_mode_put,
7997	},
7998	{ } /* end */
7999};
8000
8001static struct hda_verb alc882_base_init_verbs[] = {
8002	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8003	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8004	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8005	/* Rear mixer */
8006	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8007	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8008	/* CLFE mixer */
8009	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8010	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8011	/* Side mixer */
8012	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8013	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8014
8015	/* Front Pin: output 0 (0x0c) */
8016	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8017	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8018	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8019	/* Rear Pin: output 1 (0x0d) */
8020	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8021	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8022	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8023	/* CLFE Pin: output 2 (0x0e) */
8024	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8025	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8026	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8027	/* Side Pin: output 3 (0x0f) */
8028	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8029	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8030	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8031	/* Mic (rear) pin: input vref at 80% */
8032	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8033	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8034	/* Front Mic pin: input vref at 80% */
8035	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8036	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8037	/* Line In pin: input */
8038	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8039	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8040	/* Line-2 In: Headphone output (output 0 - 0x0c) */
8041	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8042	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8043	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8044	/* CD pin widget for input */
8045	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8046
8047	/* FIXME: use matrix-type input source selection */
8048	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8049	/* Input mixer2 */
8050	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8051	/* Input mixer3 */
8052	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8053	/* ADC2: mute amp left and right */
8054	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8055	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8056	/* ADC3: mute amp left and right */
8057	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8058	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8059
8060	{ }
8061};
8062
8063static struct hda_verb alc882_adc1_init_verbs[] = {
8064	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8065	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8066	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8067	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8068	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8069	/* ADC1: mute amp left and right */
8070	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8071	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8072	{ }
8073};
8074
8075static struct hda_verb alc882_eapd_verbs[] = {
8076	/* change to EAPD mode */
8077	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8078	{0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8079	{ }
8080};
8081
8082static struct hda_verb alc889_eapd_verbs[] = {
8083	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8084	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8085	{ }
8086};
8087
8088static struct hda_verb alc_hp15_unsol_verbs[] = {
8089	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8090	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8091	{}
8092};
8093
8094static struct hda_verb alc885_init_verbs[] = {
8095	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8096	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8097	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8098	/* Rear mixer */
8099	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8100	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8101	/* CLFE mixer */
8102	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8103	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8104	/* Side mixer */
8105	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8106	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8107
8108	/* Front HP Pin: output 0 (0x0c) */
8109	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8110	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8111	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8112	/* Front Pin: output 0 (0x0c) */
8113	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8114	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8115	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8116	/* Rear Pin: output 1 (0x0d) */
8117	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8118	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8119	{0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8120	/* CLFE Pin: output 2 (0x0e) */
8121	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8122	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8123	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8124	/* Side Pin: output 3 (0x0f) */
8125	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8126	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8127	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8128	/* Mic (rear) pin: input vref at 80% */
8129	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8130	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8131	/* Front Mic pin: input vref at 80% */
8132	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8133	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8134	/* Line In pin: input */
8135	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8136	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8137
8138	/* Mixer elements: 0x18, , 0x1a, 0x1b */
8139	/* Input mixer1 */
8140	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8141	/* Input mixer2 */
8142	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8143	/* Input mixer3 */
8144	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8145	/* ADC2: mute amp left and right */
8146	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8147	/* ADC3: mute amp left and right */
8148	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8149
8150	{ }
8151};
8152
8153static struct hda_verb alc885_init_input_verbs[] = {
8154	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8155	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8156	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8157	{ }
8158};
8159
8160
8161/* Unmute Selector 24h and set the default input to front mic */
8162static struct hda_verb alc889_init_input_verbs[] = {
8163	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8164	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8165	{ }
8166};
8167
8168
8169#define alc883_init_verbs	alc882_base_init_verbs
8170
8171/* Mac Pro test */
8172static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8173	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8174	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8175	HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8176	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8177	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8178	/* FIXME: this looks suspicious...
8179	HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8180	HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8181	*/
8182	{ } /* end */
8183};
8184
8185static struct hda_verb alc882_macpro_init_verbs[] = {
8186	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8187	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8188	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8189	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8190	/* Front Pin: output 0 (0x0c) */
8191	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8192	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8193	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8194	/* Front Mic pin: input vref at 80% */
8195	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8196	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8197	/* Speaker:  output */
8198	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8199	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8200	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8201	/* Headphone output (output 0 - 0x0c) */
8202	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8203	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8204	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8205
8206	/* FIXME: use matrix-type input source selection */
8207	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8208	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8209	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8210	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8211	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8212	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8213	/* Input mixer2 */
8214	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8215	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8216	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8217	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8218	/* Input mixer3 */
8219	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8220	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8221	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8222	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8223	/* ADC1: mute amp left and right */
8224	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8225	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8226	/* ADC2: mute amp left and right */
8227	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8228	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8229	/* ADC3: mute amp left and right */
8230	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8231	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8232
8233	{ }
8234};
8235
8236/* Macbook 5,1 */
8237static struct hda_verb alc885_mb5_init_verbs[] = {
8238	/* DACs */
8239	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8240	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8241	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8242	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8243	/* Front mixer */
8244	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8245	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8246	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8247	/* Surround mixer */
8248	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8249	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8250	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8251	/* LFE mixer */
8252	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8253	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8254	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8255	/* HP mixer */
8256	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8257	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8258	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8259	/* Front Pin (0x0c) */
8260	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8261	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8262	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8263	/* LFE Pin (0x0e) */
8264	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8265	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8266	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8267	/* HP Pin (0x0f) */
8268	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8269	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8270	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8271	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8272	/* Front Mic pin: input vref at 80% */
8273	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8274	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8275	/* Line In pin */
8276	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8277	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8278
8279	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8280	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8281	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8282	{ }
8283};
8284
8285/* Macmini 3,1 */
8286static struct hda_verb alc885_macmini3_init_verbs[] = {
8287	/* DACs */
8288	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8289	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8290	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8291	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8292	/* Front mixer */
8293	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8294	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8295	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8296	/* Surround mixer */
8297	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8298	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8299	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8300	/* LFE mixer */
8301	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8302	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8303	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8304	/* HP mixer */
8305	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8306	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8307	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8308	/* Front Pin (0x0c) */
8309	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8310	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8311	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8312	/* LFE Pin (0x0e) */
8313	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8314	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8315	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8316	/* HP Pin (0x0f) */
8317	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8318	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8319	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8320	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8321	/* Line In pin */
8322	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8323	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8324
8325	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8326	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8327	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8328	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8329	{ }
8330};
8331
8332
8333static struct hda_verb alc885_mba21_init_verbs[] = {
8334	/*Internal and HP Speaker Mixer*/
8335	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8336	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8337	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
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	/* HP Pin: output 0 (0x0e) */
8343	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8344	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8345	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8346	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8347	/* Line in (is hp when jack connected)*/
8348	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8349	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8350
8351	{ }
8352 };
8353
8354
8355/* Macbook Pro rev3 */
8356static struct hda_verb alc885_mbp3_init_verbs[] = {
8357	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8358	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8359	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8360	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8361	/* Rear mixer */
8362	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8363	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8364	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8365	/* HP mixer */
8366	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8367	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8368	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8369	/* Front Pin: output 0 (0x0c) */
8370	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8371	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8372	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8373	/* HP Pin: output 0 (0x0e) */
8374	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8375	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8376	{0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8377	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8378	/* Mic (rear) pin: input vref at 80% */
8379	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8380	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8381	/* Front Mic pin: input vref at 80% */
8382	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8383	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8384	/* Line In pin: use output 1 when in LineOut mode */
8385	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8386	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8387	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8388
8389	/* FIXME: use matrix-type input source selection */
8390	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8391	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8392	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8393	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8394	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8395	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8396	/* Input mixer2 */
8397	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8398	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8399	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8400	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8401	/* Input mixer3 */
8402	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8403	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8404	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8405	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8406	/* ADC1: mute amp left and right */
8407	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8408	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8409	/* ADC2: mute amp left and right */
8410	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8411	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8412	/* ADC3: mute amp left and right */
8413	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8414	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8415
8416	{ }
8417};
8418
8419/* iMac 9,1 */
8420static struct hda_verb alc885_imac91_init_verbs[] = {
8421	/* Internal Speaker Pin (0x0c) */
8422	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8423	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8424	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8425	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8426	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8427	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8428	/* HP Pin: Rear */
8429	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8430	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8431	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8432	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8433	/* Line in Rear */
8434	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8435	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8436	/* Front Mic pin: input vref at 80% */
8437	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8438	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8439	/* Rear mixer */
8440	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8441	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8442	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8443	/* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8444	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8445	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8446	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8447	/* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8448	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8449	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8450	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8451	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8452	/* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8453	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8454	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8455	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8456	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8457	/* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8458	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8459	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8460	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8461	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8462	/* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8463	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8464	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8465	/* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8466	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8467	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8468	/* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8469	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8470	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8471	{ }
8472};
8473
8474/* iMac 24 mixer. */
8475static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8476	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8477	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8478	{ } /* end */
8479};
8480
8481/* iMac 24 init verbs. */
8482static struct hda_verb alc885_imac24_init_verbs[] = {
8483	/* Internal speakers: output 0 (0x0c) */
8484	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8485	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8486	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8487	/* Internal speakers: output 0 (0x0c) */
8488	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8489	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8490	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8491	/* Headphone: output 0 (0x0c) */
8492	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8493	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8494	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8495	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8496	/* Front Mic: input vref at 80% */
8497	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8498	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8499	{ }
8500};
8501
8502/* Toggle speaker-output according to the hp-jack state */
8503static void alc885_imac24_setup(struct hda_codec *codec)
8504{
8505	struct alc_spec *spec = codec->spec;
8506
8507	spec->autocfg.hp_pins[0] = 0x14;
8508	spec->autocfg.speaker_pins[0] = 0x18;
8509	spec->autocfg.speaker_pins[1] = 0x1a;
8510}
8511
8512#define alc885_mb5_setup	alc885_imac24_setup
8513#define alc885_macmini3_setup	alc885_imac24_setup
8514
8515/* Macbook Air 2,1 */
8516static void alc885_mba21_setup(struct hda_codec *codec)
8517{
8518       struct alc_spec *spec = codec->spec;
8519
8520       spec->autocfg.hp_pins[0] = 0x14;
8521       spec->autocfg.speaker_pins[0] = 0x18;
8522}
8523
8524
8525
8526static void alc885_mbp3_setup(struct hda_codec *codec)
8527{
8528	struct alc_spec *spec = codec->spec;
8529
8530	spec->autocfg.hp_pins[0] = 0x15;
8531	spec->autocfg.speaker_pins[0] = 0x14;
8532}
8533
8534static void alc885_imac91_setup(struct hda_codec *codec)
8535{
8536	struct alc_spec *spec = codec->spec;
8537
8538	spec->autocfg.hp_pins[0] = 0x14;
8539	spec->autocfg.speaker_pins[0] = 0x18;
8540	spec->autocfg.speaker_pins[1] = 0x1a;
8541}
8542
8543static struct hda_verb alc882_targa_verbs[] = {
8544	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8545	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8546
8547	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8548	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8549
8550	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8551	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8552	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8553
8554	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8555	{ } /* end */
8556};
8557
8558/* toggle speaker-output according to the hp-jack state */
8559static void alc882_targa_automute(struct hda_codec *codec)
8560{
8561	struct alc_spec *spec = codec->spec;
8562	alc_automute_amp(codec);
8563	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8564				  spec->jack_present ? 1 : 3);
8565}
8566
8567static void alc882_targa_setup(struct hda_codec *codec)
8568{
8569	struct alc_spec *spec = codec->spec;
8570
8571	spec->autocfg.hp_pins[0] = 0x14;
8572	spec->autocfg.speaker_pins[0] = 0x1b;
8573}
8574
8575static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8576{
8577	if ((res >> 26) == ALC880_HP_EVENT)
8578		alc882_targa_automute(codec);
8579}
8580
8581static struct hda_verb alc882_asus_a7j_verbs[] = {
8582	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8583	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8584
8585	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8586	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8587	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8588
8589	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8590	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8591	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8592
8593	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8594	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8595	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8596	{ } /* end */
8597};
8598
8599static struct hda_verb alc882_asus_a7m_verbs[] = {
8600	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8601	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8602
8603	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8604	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8605	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8606
8607	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8608	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8609	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8610
8611	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8612	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8613	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8614 	{ } /* end */
8615};
8616
8617static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8618{
8619	unsigned int gpiostate, gpiomask, gpiodir;
8620
8621	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8622				       AC_VERB_GET_GPIO_DATA, 0);
8623
8624	if (!muted)
8625		gpiostate |= (1 << pin);
8626	else
8627		gpiostate &= ~(1 << pin);
8628
8629	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8630				      AC_VERB_GET_GPIO_MASK, 0);
8631	gpiomask |= (1 << pin);
8632
8633	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8634				     AC_VERB_GET_GPIO_DIRECTION, 0);
8635	gpiodir |= (1 << pin);
8636
8637
8638	snd_hda_codec_write(codec, codec->afg, 0,
8639			    AC_VERB_SET_GPIO_MASK, gpiomask);
8640	snd_hda_codec_write(codec, codec->afg, 0,
8641			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8642
8643	msleep(1);
8644
8645	snd_hda_codec_write(codec, codec->afg, 0,
8646			    AC_VERB_SET_GPIO_DATA, gpiostate);
8647}
8648
8649/* set up GPIO at initialization */
8650static void alc885_macpro_init_hook(struct hda_codec *codec)
8651{
8652	alc882_gpio_mute(codec, 0, 0);
8653	alc882_gpio_mute(codec, 1, 0);
8654}
8655
8656/* set up GPIO and update auto-muting at initialization */
8657static void alc885_imac24_init_hook(struct hda_codec *codec)
8658{
8659	alc885_macpro_init_hook(codec);
8660	alc_automute_amp(codec);
8661}
8662
8663/*
8664 * generic initialization of ADC, input mixers and output mixers
8665 */
8666static struct hda_verb alc883_auto_init_verbs[] = {
8667	/*
8668	 * Unmute ADC0-2 and set the default input to mic-in
8669	 */
8670	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8671	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8672	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8673	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8674
8675	/*
8676	 * Set up output mixers (0x0c - 0x0f)
8677	 */
8678	/* set vol=0 to output mixers */
8679	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8680	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8681	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8682	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8683	/* set up input amps for analog loopback */
8684	/* Amp Indices: DAC = 0, mixer = 1 */
8685	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8686	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8687	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8688	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8689	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8690	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8691	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8692	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8693	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8694	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8695
8696	/* FIXME: use matrix-type input source selection */
8697	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8698	/* Input mixer2 */
8699	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8700	/* Input mixer3 */
8701	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8702	{ }
8703};
8704
8705/* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8706static struct hda_verb alc889A_mb31_ch2_init[] = {
8707	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8708	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8709	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8710	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8711	{ } /* end */
8712};
8713
8714/* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8715static struct hda_verb alc889A_mb31_ch4_init[] = {
8716	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8717	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8718	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8719	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8720	{ } /* end */
8721};
8722
8723/* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8724static struct hda_verb alc889A_mb31_ch5_init[] = {
8725	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8726	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8727	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8728	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8729	{ } /* end */
8730};
8731
8732/* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8733static struct hda_verb alc889A_mb31_ch6_init[] = {
8734	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8735	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8736	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8737	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8738	{ } /* end */
8739};
8740
8741static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8742	{ 2, alc889A_mb31_ch2_init },
8743	{ 4, alc889A_mb31_ch4_init },
8744	{ 5, alc889A_mb31_ch5_init },
8745	{ 6, alc889A_mb31_ch6_init },
8746};
8747
8748static struct hda_verb alc883_medion_eapd_verbs[] = {
8749        /* eanable EAPD on medion laptop */
8750	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8751	{0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8752	{ }
8753};
8754
8755#define alc883_base_mixer	alc882_base_mixer
8756
8757static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8758	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8759	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8760	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8761	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8762	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8763	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8764	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8765	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8766	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8767	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8768	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8769	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8770	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8771	{ } /* end */
8772};
8773
8774static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8775	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8776	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8777	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8778	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8779	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8780	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8781	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8782	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8783	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8784	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8785	{ } /* end */
8786};
8787
8788static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8789	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8790	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8791	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8792	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8793	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8794	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8795	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8796	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8797	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8798	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8799	{ } /* end */
8800};
8801
8802static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8803	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8804	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8805	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8806	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8807	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8808	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8809	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8810	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8811	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8812	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8813	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8814	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8815	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8816	{ } /* end */
8817};
8818
8819static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8820	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8821	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8822	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8823	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8824	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8825	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8826	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8827	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8828	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8829	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8830	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8831	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8832	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8833	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8834	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8835	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8836	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8837	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8838	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8839	{ } /* end */
8840};
8841
8842static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8843	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8844	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8845	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8846	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8847	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8848			      HDA_OUTPUT),
8849	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8850	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8851	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8852	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8853	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8854	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8855	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8856	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8857	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8858	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8859	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8860	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8861	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8862	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8863	{ } /* end */
8864};
8865
8866static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8867	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8868	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8869	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8870	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8871	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8872			      HDA_OUTPUT),
8873	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8874	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8875	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8876	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8877	HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8878	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8879	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8880	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8881	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8882	HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8883	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8884	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8885	HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8886	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8887	{ } /* end */
8888};
8889
8890static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8891	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8892	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8893	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8894	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8895	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8896	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8897	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8898	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8899	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8900	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8901	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8902	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8903	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8904	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8905	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8906	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8907	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8908	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8909	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8910	{ } /* end */
8911};
8912
8913static struct snd_kcontrol_new alc883_targa_mixer[] = {
8914	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8915	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8916	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8917	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8918	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8919	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8920	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8921	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8922	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8923	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8924	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8925	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8926	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8927	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8928	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8929	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8930	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8931	{ } /* end */
8932};
8933
8934static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8935	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8936	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8937	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8938	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8939	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8940	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8941	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8942	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8943	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8944	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8945	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8946	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8947	{ } /* end */
8948};
8949
8950static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8951	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8952	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8953	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8954	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8955	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8956	{ } /* end */
8957};
8958
8959static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8960	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8961	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8962	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8963	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8964	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8965	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8966	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8967	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8968	{ } /* end */
8969};
8970
8971static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8972	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8973	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8974	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8975	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8976	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8977	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8978	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8979	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8980	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8981	{ } /* end */
8982};
8983
8984static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8985	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8986	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8987	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8988	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8989	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8990	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8991	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8992	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8993	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8994	{ } /* end */
8995};
8996
8997static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
8998	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8999	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9000	HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9001	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9002	HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9003	HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9004	{ } /* end */
9005};
9006
9007static struct hda_verb alc883_medion_wim2160_verbs[] = {
9008	/* Unmute front mixer */
9009	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9010	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9011
9012	/* Set speaker pin to front mixer */
9013	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9014
9015	/* Init headphone pin */
9016	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9017	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9018	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9019	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9020
9021	{ } /* end */
9022};
9023
9024/* toggle speaker-output according to the hp-jack state */
9025static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9026{
9027	struct alc_spec *spec = codec->spec;
9028
9029	spec->autocfg.hp_pins[0] = 0x1a;
9030	spec->autocfg.speaker_pins[0] = 0x15;
9031}
9032
9033static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9034	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9035	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9036	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9037	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9038	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9039	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9040	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9041	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9042	{ } /* end */
9043};
9044
9045static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9046	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9047	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9048	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9049	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9050	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9051	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9052	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9053	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9054	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9055	{ } /* end */
9056};
9057
9058static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9059	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9060	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9061	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9062	HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9063	HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9064						0x0d, 1, 0x0, HDA_OUTPUT),
9065	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9066	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9067	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9068	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9069	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9070	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9071	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9072	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9073	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9074	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9075	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9076	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9077	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9078	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9079	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9080	{ } /* end */
9081};
9082
9083static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9084	/* Output mixers */
9085	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9086	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9087	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9088	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9089	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9090		HDA_OUTPUT),
9091	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9092	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9093	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9094	/* Output switches */
9095	HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9096	HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9097	HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9098	/* Boost mixers */
9099	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
9100	HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
9101	/* Input mixers */
9102	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9103	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9104	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9105	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9106	{ } /* end */
9107};
9108
9109static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9110	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9111	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9112	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9113	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9114	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
9115	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9116	{ } /* end */
9117};
9118
9119static struct hda_bind_ctls alc883_bind_cap_vol = {
9120	.ops = &snd_hda_bind_vol,
9121	.values = {
9122		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9123		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9124		0
9125	},
9126};
9127
9128static struct hda_bind_ctls alc883_bind_cap_switch = {
9129	.ops = &snd_hda_bind_sw,
9130	.values = {
9131		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9132		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9133		0
9134	},
9135};
9136
9137static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9138	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9139	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9140	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9141	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9142	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9143	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9144	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9145	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9146	{ } /* end */
9147};
9148
9149static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9150	HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9151	HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9152	{
9153		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9154		/* .name = "Capture Source", */
9155		.name = "Input Source",
9156		.count = 1,
9157		.info = alc_mux_enum_info,
9158		.get = alc_mux_enum_get,
9159		.put = alc_mux_enum_put,
9160	},
9161	{ } /* end */
9162};
9163
9164static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9165	{
9166		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9167		.name = "Channel Mode",
9168		.info = alc_ch_mode_info,
9169		.get = alc_ch_mode_get,
9170		.put = alc_ch_mode_put,
9171	},
9172	{ } /* end */
9173};
9174
9175/* toggle speaker-output according to the hp-jack state */
9176static void alc883_mitac_setup(struct hda_codec *codec)
9177{
9178	struct alc_spec *spec = codec->spec;
9179
9180	spec->autocfg.hp_pins[0] = 0x15;
9181	spec->autocfg.speaker_pins[0] = 0x14;
9182	spec->autocfg.speaker_pins[1] = 0x17;
9183}
9184
9185/* auto-toggle front mic */
9186/*
9187static void alc883_mitac_mic_automute(struct hda_codec *codec)
9188{
9189	unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
9190
9191	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
9192}
9193*/
9194
9195static struct hda_verb alc883_mitac_verbs[] = {
9196	/* HP */
9197	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9198	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9199	/* Subwoofer */
9200	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9201	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9202
9203	/* enable unsolicited event */
9204	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9205	/* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9206
9207	{ } /* end */
9208};
9209
9210static struct hda_verb alc883_clevo_m540r_verbs[] = {
9211	/* HP */
9212	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9213	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9214	/* Int speaker */
9215	/*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9216
9217	/* enable unsolicited event */
9218	/*
9219	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9220	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9221	*/
9222
9223	{ } /* end */
9224};
9225
9226static struct hda_verb alc883_clevo_m720_verbs[] = {
9227	/* HP */
9228	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9229	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9230	/* Int speaker */
9231	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9232	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9233
9234	/* enable unsolicited event */
9235	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9236	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9237
9238	{ } /* end */
9239};
9240
9241static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9242	/* HP */
9243	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9244	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9245	/* Subwoofer */
9246	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9247	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9248
9249	/* enable unsolicited event */
9250	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9251
9252	{ } /* end */
9253};
9254
9255static struct hda_verb alc883_targa_verbs[] = {
9256	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9257	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9258
9259	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9260	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9261
9262/* Connect Line-Out side jack (SPDIF) to Side */
9263	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9264	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9265	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9266/* Connect Mic jack to CLFE */
9267	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9268	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9269	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9270/* Connect Line-in jack to Surround */
9271	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9272	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9273	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9274/* Connect HP out jack to Front */
9275	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9276	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9277	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9278
9279	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9280
9281	{ } /* end */
9282};
9283
9284static struct hda_verb alc883_lenovo_101e_verbs[] = {
9285	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9286	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9287        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9288	{ } /* end */
9289};
9290
9291static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9292        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9293	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9294        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9295        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9296	{ } /* end */
9297};
9298
9299static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9300	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9301	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9302	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9303	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9304	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9305	{ } /* end */
9306};
9307
9308static struct hda_verb alc883_haier_w66_verbs[] = {
9309	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9310	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9311
9312	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9313
9314	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9315	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9316	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9317	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9318	{ } /* end */
9319};
9320
9321static struct hda_verb alc888_lenovo_sky_verbs[] = {
9322	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9323	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9324	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9325	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9326	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9327	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9328	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9329	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9330	{ } /* end */
9331};
9332
9333static struct hda_verb alc888_6st_dell_verbs[] = {
9334	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9335	{ }
9336};
9337
9338static struct hda_verb alc883_vaiott_verbs[] = {
9339	/* HP */
9340	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9341	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9342
9343	/* enable unsolicited event */
9344	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9345
9346	{ } /* end */
9347};
9348
9349static void alc888_3st_hp_setup(struct hda_codec *codec)
9350{
9351	struct alc_spec *spec = codec->spec;
9352
9353	spec->autocfg.hp_pins[0] = 0x1b;
9354	spec->autocfg.speaker_pins[0] = 0x14;
9355	spec->autocfg.speaker_pins[1] = 0x16;
9356	spec->autocfg.speaker_pins[2] = 0x18;
9357}
9358
9359static struct hda_verb alc888_3st_hp_verbs[] = {
9360	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Front: output 0 (0x0c) */
9361	{0x16, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Rear : output 1 (0x0d) */
9362	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},	/* CLFE : output 2 (0x0e) */
9363	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9364	{ } /* end */
9365};
9366
9367/*
9368 * 2ch mode
9369 */
9370static struct hda_verb alc888_3st_hp_2ch_init[] = {
9371	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9372	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9373	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9374	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9375	{ } /* end */
9376};
9377
9378/*
9379 * 4ch mode
9380 */
9381static struct hda_verb alc888_3st_hp_4ch_init[] = {
9382	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9383	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9384	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9385	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9386	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9387	{ } /* end */
9388};
9389
9390/*
9391 * 6ch mode
9392 */
9393static struct hda_verb alc888_3st_hp_6ch_init[] = {
9394	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9395	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9396	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9397	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9398	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9399	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9400	{ } /* end */
9401};
9402
9403static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9404	{ 2, alc888_3st_hp_2ch_init },
9405	{ 4, alc888_3st_hp_4ch_init },
9406	{ 6, alc888_3st_hp_6ch_init },
9407};
9408
9409/* toggle front-jack and RCA according to the hp-jack state */
9410static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9411{
9412 	unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9413
9414	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9415				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9416	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9417				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9418}
9419
9420/* toggle RCA according to the front-jack state */
9421static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9422{
9423 	unsigned int present = snd_hda_jack_detect(codec, 0x14);
9424
9425	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9426				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9427}
9428
9429static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9430					     unsigned int res)
9431{
9432	if ((res >> 26) == ALC880_HP_EVENT)
9433		alc888_lenovo_ms7195_front_automute(codec);
9434	if ((res >> 26) == ALC880_FRONT_EVENT)
9435		alc888_lenovo_ms7195_rca_automute(codec);
9436}
9437
9438static struct hda_verb alc883_medion_md2_verbs[] = {
9439	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9440	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9441
9442	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9443
9444	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9445	{ } /* end */
9446};
9447
9448/* toggle speaker-output according to the hp-jack state */
9449static void alc883_medion_md2_setup(struct hda_codec *codec)
9450{
9451	struct alc_spec *spec = codec->spec;
9452
9453	spec->autocfg.hp_pins[0] = 0x14;
9454	spec->autocfg.speaker_pins[0] = 0x15;
9455}
9456
9457/* toggle speaker-output according to the hp-jack state */
9458#define alc883_targa_init_hook		alc882_targa_init_hook
9459#define alc883_targa_unsol_event	alc882_targa_unsol_event
9460
9461static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
9462{
9463	unsigned int present;
9464
9465	present = snd_hda_jack_detect(codec, 0x18);
9466	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
9467				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9468}
9469
9470static void alc883_clevo_m720_setup(struct hda_codec *codec)
9471{
9472	struct alc_spec *spec = codec->spec;
9473
9474	spec->autocfg.hp_pins[0] = 0x15;
9475	spec->autocfg.speaker_pins[0] = 0x14;
9476}
9477
9478static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9479{
9480	alc_automute_amp(codec);
9481	alc883_clevo_m720_mic_automute(codec);
9482}
9483
9484static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9485					   unsigned int res)
9486{
9487	switch (res >> 26) {
9488	case ALC880_MIC_EVENT:
9489		alc883_clevo_m720_mic_automute(codec);
9490		break;
9491	default:
9492		alc_automute_amp_unsol_event(codec, res);
9493		break;
9494	}
9495}
9496
9497/* toggle speaker-output according to the hp-jack state */
9498static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9499{
9500	struct alc_spec *spec = codec->spec;
9501
9502	spec->autocfg.hp_pins[0] = 0x14;
9503	spec->autocfg.speaker_pins[0] = 0x15;
9504}
9505
9506static void alc883_haier_w66_setup(struct hda_codec *codec)
9507{
9508	struct alc_spec *spec = codec->spec;
9509
9510	spec->autocfg.hp_pins[0] = 0x1b;
9511	spec->autocfg.speaker_pins[0] = 0x14;
9512}
9513
9514static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9515{
9516	int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9517
9518	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9519				 HDA_AMP_MUTE, bits);
9520}
9521
9522static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9523{
9524	int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9525
9526	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9527				 HDA_AMP_MUTE, bits);
9528	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9529				 HDA_AMP_MUTE, bits);
9530}
9531
9532static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9533					   unsigned int res)
9534{
9535	if ((res >> 26) == ALC880_HP_EVENT)
9536		alc883_lenovo_101e_all_automute(codec);
9537	if ((res >> 26) == ALC880_FRONT_EVENT)
9538		alc883_lenovo_101e_ispeaker_automute(codec);
9539}
9540
9541/* toggle speaker-output according to the hp-jack state */
9542static void alc883_acer_aspire_setup(struct hda_codec *codec)
9543{
9544	struct alc_spec *spec = codec->spec;
9545
9546	spec->autocfg.hp_pins[0] = 0x14;
9547	spec->autocfg.speaker_pins[0] = 0x15;
9548	spec->autocfg.speaker_pins[1] = 0x16;
9549}
9550
9551static struct hda_verb alc883_acer_eapd_verbs[] = {
9552	/* HP Pin: output 0 (0x0c) */
9553	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9554	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9555	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9556	/* Front Pin: output 0 (0x0c) */
9557	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9558	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9559	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9560	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9561        /* eanable EAPD on medion laptop */
9562	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9563	{0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9564	/* enable unsolicited event */
9565	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9566	{ }
9567};
9568
9569static void alc888_6st_dell_setup(struct hda_codec *codec)
9570{
9571	struct alc_spec *spec = codec->spec;
9572
9573	spec->autocfg.hp_pins[0] = 0x1b;
9574	spec->autocfg.speaker_pins[0] = 0x14;
9575	spec->autocfg.speaker_pins[1] = 0x15;
9576	spec->autocfg.speaker_pins[2] = 0x16;
9577	spec->autocfg.speaker_pins[3] = 0x17;
9578}
9579
9580static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9581{
9582	struct alc_spec *spec = codec->spec;
9583
9584	spec->autocfg.hp_pins[0] = 0x1b;
9585	spec->autocfg.speaker_pins[0] = 0x14;
9586	spec->autocfg.speaker_pins[1] = 0x15;
9587	spec->autocfg.speaker_pins[2] = 0x16;
9588	spec->autocfg.speaker_pins[3] = 0x17;
9589	spec->autocfg.speaker_pins[4] = 0x1a;
9590}
9591
9592static void alc883_vaiott_setup(struct hda_codec *codec)
9593{
9594	struct alc_spec *spec = codec->spec;
9595
9596	spec->autocfg.hp_pins[0] = 0x15;
9597	spec->autocfg.speaker_pins[0] = 0x14;
9598	spec->autocfg.speaker_pins[1] = 0x17;
9599}
9600
9601static struct hda_verb alc888_asus_m90v_verbs[] = {
9602	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9603	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9604	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9605	/* enable unsolicited event */
9606	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9607	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9608	{ } /* end */
9609};
9610
9611static void alc883_mode2_setup(struct hda_codec *codec)
9612{
9613	struct alc_spec *spec = codec->spec;
9614
9615	spec->autocfg.hp_pins[0] = 0x1b;
9616	spec->autocfg.speaker_pins[0] = 0x14;
9617	spec->autocfg.speaker_pins[1] = 0x15;
9618	spec->autocfg.speaker_pins[2] = 0x16;
9619	spec->ext_mic.pin = 0x18;
9620	spec->int_mic.pin = 0x19;
9621	spec->ext_mic.mux_idx = 0;
9622	spec->int_mic.mux_idx = 1;
9623	spec->auto_mic = 1;
9624}
9625
9626static struct hda_verb alc888_asus_eee1601_verbs[] = {
9627	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9628	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9629	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9630	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9631	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9632	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9633	{0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9634	/* enable unsolicited event */
9635	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9636	{ } /* end */
9637};
9638
9639static void alc883_eee1601_inithook(struct hda_codec *codec)
9640{
9641	struct alc_spec *spec = codec->spec;
9642
9643	spec->autocfg.hp_pins[0] = 0x14;
9644	spec->autocfg.speaker_pins[0] = 0x1b;
9645	alc_automute_pin(codec);
9646}
9647
9648static struct hda_verb alc889A_mb31_verbs[] = {
9649	/* Init rear pin (used as headphone output) */
9650	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9651	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9652	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9653	/* Init line pin (used as output in 4ch and 6ch mode) */
9654	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9655	/* Init line 2 pin (used as headphone out by default) */
9656	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9657	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9658	{ } /* end */
9659};
9660
9661/* Mute speakers according to the headphone jack state */
9662static void alc889A_mb31_automute(struct hda_codec *codec)
9663{
9664	unsigned int present;
9665
9666	/* Mute only in 2ch or 4ch mode */
9667	if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9668	    == 0x00) {
9669		present = snd_hda_jack_detect(codec, 0x15);
9670		snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9671			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9672		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9673			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9674	}
9675}
9676
9677static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9678{
9679	if ((res >> 26) == ALC880_HP_EVENT)
9680		alc889A_mb31_automute(codec);
9681}
9682
9683
9684#ifdef CONFIG_SND_HDA_POWER_SAVE
9685#define alc882_loopbacks	alc880_loopbacks
9686#endif
9687
9688/* pcm configuration: identical with ALC880 */
9689#define alc882_pcm_analog_playback	alc880_pcm_analog_playback
9690#define alc882_pcm_analog_capture	alc880_pcm_analog_capture
9691#define alc882_pcm_digital_playback	alc880_pcm_digital_playback
9692#define alc882_pcm_digital_capture	alc880_pcm_digital_capture
9693
9694static hda_nid_t alc883_slave_dig_outs[] = {
9695	ALC1200_DIGOUT_NID, 0,
9696};
9697
9698static hda_nid_t alc1200_slave_dig_outs[] = {
9699	ALC883_DIGOUT_NID, 0,
9700};
9701
9702/*
9703 * configuration and preset
9704 */
9705static const char *alc882_models[ALC882_MODEL_LAST] = {
9706	[ALC882_3ST_DIG]	= "3stack-dig",
9707	[ALC882_6ST_DIG]	= "6stack-dig",
9708	[ALC882_ARIMA]		= "arima",
9709	[ALC882_W2JC]		= "w2jc",
9710	[ALC882_TARGA]		= "targa",
9711	[ALC882_ASUS_A7J]	= "asus-a7j",
9712	[ALC882_ASUS_A7M]	= "asus-a7m",
9713	[ALC885_MACPRO]		= "macpro",
9714	[ALC885_MB5]		= "mb5",
9715	[ALC885_MACMINI3]	= "macmini3",
9716	[ALC885_MBA21]		= "mba21",
9717	[ALC885_MBP3]		= "mbp3",
9718	[ALC885_IMAC24]		= "imac24",
9719	[ALC885_IMAC91]		= "imac91",
9720	[ALC883_3ST_2ch_DIG]	= "3stack-2ch-dig",
9721	[ALC883_3ST_6ch_DIG]	= "3stack-6ch-dig",
9722	[ALC883_3ST_6ch]	= "3stack-6ch",
9723	[ALC883_6ST_DIG]	= "alc883-6stack-dig",
9724	[ALC883_TARGA_DIG]	= "targa-dig",
9725	[ALC883_TARGA_2ch_DIG]	= "targa-2ch-dig",
9726	[ALC883_TARGA_8ch_DIG]	= "targa-8ch-dig",
9727	[ALC883_ACER]		= "acer",
9728	[ALC883_ACER_ASPIRE]	= "acer-aspire",
9729	[ALC888_ACER_ASPIRE_4930G]	= "acer-aspire-4930g",
9730	[ALC888_ACER_ASPIRE_6530G]	= "acer-aspire-6530g",
9731	[ALC888_ACER_ASPIRE_8930G]	= "acer-aspire-8930g",
9732	[ALC888_ACER_ASPIRE_7730G]	= "acer-aspire-7730g",
9733	[ALC883_MEDION]		= "medion",
9734	[ALC883_MEDION_MD2]	= "medion-md2",
9735	[ALC883_MEDION_WIM2160]	= "medion-wim2160",
9736	[ALC883_LAPTOP_EAPD]	= "laptop-eapd",
9737	[ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9738	[ALC883_LENOVO_NB0763]	= "lenovo-nb0763",
9739	[ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9740	[ALC888_LENOVO_SKY] = "lenovo-sky",
9741	[ALC883_HAIER_W66] 	= "haier-w66",
9742	[ALC888_3ST_HP]		= "3stack-hp",
9743	[ALC888_6ST_DELL]	= "6stack-dell",
9744	[ALC883_MITAC]		= "mitac",
9745	[ALC883_CLEVO_M540R]	= "clevo-m540r",
9746	[ALC883_CLEVO_M720]	= "clevo-m720",
9747	[ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9748	[ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9749	[ALC883_3ST_6ch_INTEL]	= "3stack-6ch-intel",
9750	[ALC889A_INTEL]		= "intel-alc889a",
9751	[ALC889_INTEL]		= "intel-x58",
9752	[ALC1200_ASUS_P5Q]	= "asus-p5q",
9753	[ALC889A_MB31]		= "mb31",
9754	[ALC883_SONY_VAIO_TT]	= "sony-vaio-tt",
9755	[ALC882_AUTO]		= "auto",
9756};
9757
9758static struct snd_pci_quirk alc882_cfg_tbl[] = {
9759	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9760
9761	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9762	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9763	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9764	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9765	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9766	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9767	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9768		ALC888_ACER_ASPIRE_4930G),
9769	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9770		ALC888_ACER_ASPIRE_4930G),
9771	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9772		ALC888_ACER_ASPIRE_8930G),
9773	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9774		ALC888_ACER_ASPIRE_8930G),
9775	SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9776	SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9777	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9778		ALC888_ACER_ASPIRE_6530G),
9779	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9780		ALC888_ACER_ASPIRE_6530G),
9781	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9782		ALC888_ACER_ASPIRE_7730G),
9783	/* default Acer -- disabled as it causes more problems.
9784	 *    model=auto should work fine now
9785	 */
9786	/* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9787
9788	SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9789
9790	SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9791	SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9792	SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9793	SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9794	SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9795	SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9796
9797	SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9798	SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9799	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9800	SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9801	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9802	SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9803	SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9804	SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9805	SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9806	SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9807	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9808
9809	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9810	SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9811	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9812	SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9813	SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9814	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9815	SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9816	SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9817	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9818
9819	SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9820	SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9821	SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9822	SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9823	SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9824	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9825	SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9826	SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9827	SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9828	SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9829	SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9830	SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9831	SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9832	SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9833	SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9834	SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9835	SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9836	SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9837	SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9838	SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9839	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9840	SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9841	SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9842	SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9843	SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9844	SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9845	SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9846	SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9847	SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9848	SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9849	SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9850
9851	SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9852	SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9853	SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9854	SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9855	SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9856	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9857	SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9858	/* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9859	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9860	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9861		      ALC883_FUJITSU_PI2515),
9862	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9863		ALC888_FUJITSU_XA3530),
9864	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9865	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9866	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9867	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9868	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9869	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9870	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9871	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9872
9873	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9874	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9875	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9876	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9877	SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9878	SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9879	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9880
9881	{}
9882};
9883
9884/* codec SSID table for Intel Mac */
9885static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9886	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9887	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9888	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9889	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9890	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9891	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9892	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9893	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9894	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9895	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9896	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9897	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9898	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9899	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9900	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9901	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9902	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9903	/* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9904	 * so apparently no perfect solution yet
9905	 */
9906	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9907	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9908	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9909	{} /* terminator */
9910};
9911
9912static struct alc_config_preset alc882_presets[] = {
9913	[ALC882_3ST_DIG] = {
9914		.mixers = { alc882_base_mixer },
9915		.init_verbs = { alc882_base_init_verbs,
9916				alc882_adc1_init_verbs },
9917		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9918		.dac_nids = alc882_dac_nids,
9919		.dig_out_nid = ALC882_DIGOUT_NID,
9920		.dig_in_nid = ALC882_DIGIN_NID,
9921		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9922		.channel_mode = alc882_ch_modes,
9923		.need_dac_fix = 1,
9924		.input_mux = &alc882_capture_source,
9925	},
9926	[ALC882_6ST_DIG] = {
9927		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9928		.init_verbs = { alc882_base_init_verbs,
9929				alc882_adc1_init_verbs },
9930		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9931		.dac_nids = alc882_dac_nids,
9932		.dig_out_nid = ALC882_DIGOUT_NID,
9933		.dig_in_nid = ALC882_DIGIN_NID,
9934		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9935		.channel_mode = alc882_sixstack_modes,
9936		.input_mux = &alc882_capture_source,
9937	},
9938	[ALC882_ARIMA] = {
9939		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9940		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9941				alc882_eapd_verbs },
9942		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9943		.dac_nids = alc882_dac_nids,
9944		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9945		.channel_mode = alc882_sixstack_modes,
9946		.input_mux = &alc882_capture_source,
9947	},
9948	[ALC882_W2JC] = {
9949		.mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9950		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9951				alc882_eapd_verbs, alc880_gpio1_init_verbs },
9952		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9953		.dac_nids = alc882_dac_nids,
9954		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9955		.channel_mode = alc880_threestack_modes,
9956		.need_dac_fix = 1,
9957		.input_mux = &alc882_capture_source,
9958		.dig_out_nid = ALC882_DIGOUT_NID,
9959	},
9960	   [ALC885_MBA21] = {
9961			.mixers = { alc885_mba21_mixer },
9962			.init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9963			.num_dacs = 2,
9964			.dac_nids = alc882_dac_nids,
9965			.channel_mode = alc885_mba21_ch_modes,
9966			.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9967			.input_mux = &alc882_capture_source,
9968			.unsol_event = alc_automute_amp_unsol_event,
9969			.setup = alc885_mba21_setup,
9970			.init_hook = alc_automute_amp,
9971       },
9972	[ALC885_MBP3] = {
9973		.mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9974		.init_verbs = { alc885_mbp3_init_verbs,
9975				alc880_gpio1_init_verbs },
9976		.num_dacs = 2,
9977		.dac_nids = alc882_dac_nids,
9978		.hp_nid = 0x04,
9979		.channel_mode = alc885_mbp_4ch_modes,
9980		.num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9981		.input_mux = &alc882_capture_source,
9982		.dig_out_nid = ALC882_DIGOUT_NID,
9983		.dig_in_nid = ALC882_DIGIN_NID,
9984		.unsol_event = alc_automute_amp_unsol_event,
9985		.setup = alc885_mbp3_setup,
9986		.init_hook = alc_automute_amp,
9987	},
9988	[ALC885_MB5] = {
9989		.mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9990		.init_verbs = { alc885_mb5_init_verbs,
9991				alc880_gpio1_init_verbs },
9992		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9993		.dac_nids = alc882_dac_nids,
9994		.channel_mode = alc885_mb5_6ch_modes,
9995		.num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9996		.input_mux = &mb5_capture_source,
9997		.dig_out_nid = ALC882_DIGOUT_NID,
9998		.dig_in_nid = ALC882_DIGIN_NID,
9999		.unsol_event = alc_automute_amp_unsol_event,
10000		.setup = alc885_mb5_setup,
10001		.init_hook = alc_automute_amp,
10002	},
10003	[ALC885_MACMINI3] = {
10004		.mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10005		.init_verbs = { alc885_macmini3_init_verbs,
10006				alc880_gpio1_init_verbs },
10007		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10008		.dac_nids = alc882_dac_nids,
10009		.channel_mode = alc885_macmini3_6ch_modes,
10010		.num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10011		.input_mux = &macmini3_capture_source,
10012		.dig_out_nid = ALC882_DIGOUT_NID,
10013		.dig_in_nid = ALC882_DIGIN_NID,
10014		.unsol_event = alc_automute_amp_unsol_event,
10015		.setup = alc885_macmini3_setup,
10016		.init_hook = alc_automute_amp,
10017	},
10018	[ALC885_MACPRO] = {
10019		.mixers = { alc882_macpro_mixer },
10020		.init_verbs = { alc882_macpro_init_verbs },
10021		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10022		.dac_nids = alc882_dac_nids,
10023		.dig_out_nid = ALC882_DIGOUT_NID,
10024		.dig_in_nid = ALC882_DIGIN_NID,
10025		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10026		.channel_mode = alc882_ch_modes,
10027		.input_mux = &alc882_capture_source,
10028		.init_hook = alc885_macpro_init_hook,
10029	},
10030	[ALC885_IMAC24] = {
10031		.mixers = { alc885_imac24_mixer },
10032		.init_verbs = { alc885_imac24_init_verbs },
10033		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10034		.dac_nids = alc882_dac_nids,
10035		.dig_out_nid = ALC882_DIGOUT_NID,
10036		.dig_in_nid = ALC882_DIGIN_NID,
10037		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10038		.channel_mode = alc882_ch_modes,
10039		.input_mux = &alc882_capture_source,
10040		.unsol_event = alc_automute_amp_unsol_event,
10041		.setup = alc885_imac24_setup,
10042		.init_hook = alc885_imac24_init_hook,
10043	},
10044	[ALC885_IMAC91] = {
10045		.mixers = {alc885_imac91_mixer},
10046		.init_verbs = { alc885_imac91_init_verbs,
10047				alc880_gpio1_init_verbs },
10048		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10049		.dac_nids = alc882_dac_nids,
10050		.channel_mode = alc885_mba21_ch_modes,
10051		.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10052		.input_mux = &alc889A_imac91_capture_source,
10053		.dig_out_nid = ALC882_DIGOUT_NID,
10054		.dig_in_nid = ALC882_DIGIN_NID,
10055		.unsol_event = alc_automute_amp_unsol_event,
10056		.setup = alc885_imac91_setup,
10057		.init_hook = alc_automute_amp,
10058	},
10059	[ALC882_TARGA] = {
10060		.mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10061		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10062				alc880_gpio3_init_verbs, alc882_targa_verbs},
10063		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10064		.dac_nids = alc882_dac_nids,
10065		.dig_out_nid = ALC882_DIGOUT_NID,
10066		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10067		.adc_nids = alc882_adc_nids,
10068		.capsrc_nids = alc882_capsrc_nids,
10069		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10070		.channel_mode = alc882_3ST_6ch_modes,
10071		.need_dac_fix = 1,
10072		.input_mux = &alc882_capture_source,
10073		.unsol_event = alc882_targa_unsol_event,
10074		.setup = alc882_targa_setup,
10075		.init_hook = alc882_targa_automute,
10076	},
10077	[ALC882_ASUS_A7J] = {
10078		.mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10079		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10080				alc882_asus_a7j_verbs},
10081		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10082		.dac_nids = alc882_dac_nids,
10083		.dig_out_nid = ALC882_DIGOUT_NID,
10084		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10085		.adc_nids = alc882_adc_nids,
10086		.capsrc_nids = alc882_capsrc_nids,
10087		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10088		.channel_mode = alc882_3ST_6ch_modes,
10089		.need_dac_fix = 1,
10090		.input_mux = &alc882_capture_source,
10091	},
10092	[ALC882_ASUS_A7M] = {
10093		.mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10094		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10095				alc882_eapd_verbs, alc880_gpio1_init_verbs,
10096				alc882_asus_a7m_verbs },
10097		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10098		.dac_nids = alc882_dac_nids,
10099		.dig_out_nid = ALC882_DIGOUT_NID,
10100		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10101		.channel_mode = alc880_threestack_modes,
10102		.need_dac_fix = 1,
10103		.input_mux = &alc882_capture_source,
10104	},
10105	[ALC883_3ST_2ch_DIG] = {
10106		.mixers = { alc883_3ST_2ch_mixer },
10107		.init_verbs = { alc883_init_verbs },
10108		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10109		.dac_nids = alc883_dac_nids,
10110		.dig_out_nid = ALC883_DIGOUT_NID,
10111		.dig_in_nid = ALC883_DIGIN_NID,
10112		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10113		.channel_mode = alc883_3ST_2ch_modes,
10114		.input_mux = &alc883_capture_source,
10115	},
10116	[ALC883_3ST_6ch_DIG] = {
10117		.mixers = { alc883_3ST_6ch_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_3ST_6ch_modes),
10124		.channel_mode = alc883_3ST_6ch_modes,
10125		.need_dac_fix = 1,
10126		.input_mux = &alc883_capture_source,
10127	},
10128	[ALC883_3ST_6ch] = {
10129		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10130		.init_verbs = { alc883_init_verbs },
10131		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10132		.dac_nids = alc883_dac_nids,
10133		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10134		.channel_mode = alc883_3ST_6ch_modes,
10135		.need_dac_fix = 1,
10136		.input_mux = &alc883_capture_source,
10137	},
10138	[ALC883_3ST_6ch_INTEL] = {
10139		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10140		.init_verbs = { alc883_init_verbs },
10141		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10142		.dac_nids = alc883_dac_nids,
10143		.dig_out_nid = ALC883_DIGOUT_NID,
10144		.dig_in_nid = ALC883_DIGIN_NID,
10145		.slave_dig_outs = alc883_slave_dig_outs,
10146		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10147		.channel_mode = alc883_3ST_6ch_intel_modes,
10148		.need_dac_fix = 1,
10149		.input_mux = &alc883_3stack_6ch_intel,
10150	},
10151	[ALC889A_INTEL] = {
10152		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10153		.init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10154				alc_hp15_unsol_verbs },
10155		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10156		.dac_nids = alc883_dac_nids,
10157		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10158		.adc_nids = alc889_adc_nids,
10159		.dig_out_nid = ALC883_DIGOUT_NID,
10160		.dig_in_nid = ALC883_DIGIN_NID,
10161		.slave_dig_outs = alc883_slave_dig_outs,
10162		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10163		.channel_mode = alc889_8ch_intel_modes,
10164		.capsrc_nids = alc889_capsrc_nids,
10165		.input_mux = &alc889_capture_source,
10166		.setup = alc889_automute_setup,
10167		.init_hook = alc_automute_amp,
10168		.unsol_event = alc_automute_amp_unsol_event,
10169		.need_dac_fix = 1,
10170	},
10171	[ALC889_INTEL] = {
10172		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10173		.init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10174				alc889_eapd_verbs, alc_hp15_unsol_verbs},
10175		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10176		.dac_nids = alc883_dac_nids,
10177		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10178		.adc_nids = alc889_adc_nids,
10179		.dig_out_nid = ALC883_DIGOUT_NID,
10180		.dig_in_nid = ALC883_DIGIN_NID,
10181		.slave_dig_outs = alc883_slave_dig_outs,
10182		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10183		.channel_mode = alc889_8ch_intel_modes,
10184		.capsrc_nids = alc889_capsrc_nids,
10185		.input_mux = &alc889_capture_source,
10186		.setup = alc889_automute_setup,
10187		.init_hook = alc889_intel_init_hook,
10188		.unsol_event = alc_automute_amp_unsol_event,
10189		.need_dac_fix = 1,
10190	},
10191	[ALC883_6ST_DIG] = {
10192		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10193		.init_verbs = { alc883_init_verbs },
10194		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10195		.dac_nids = alc883_dac_nids,
10196		.dig_out_nid = ALC883_DIGOUT_NID,
10197		.dig_in_nid = ALC883_DIGIN_NID,
10198		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10199		.channel_mode = alc883_sixstack_modes,
10200		.input_mux = &alc883_capture_source,
10201	},
10202	[ALC883_TARGA_DIG] = {
10203		.mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10204		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10205				alc883_targa_verbs},
10206		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10207		.dac_nids = alc883_dac_nids,
10208		.dig_out_nid = ALC883_DIGOUT_NID,
10209		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10210		.channel_mode = alc883_3ST_6ch_modes,
10211		.need_dac_fix = 1,
10212		.input_mux = &alc883_capture_source,
10213		.unsol_event = alc883_targa_unsol_event,
10214		.setup = alc882_targa_setup,
10215		.init_hook = alc882_targa_automute,
10216	},
10217	[ALC883_TARGA_2ch_DIG] = {
10218		.mixers = { alc883_targa_2ch_mixer},
10219		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10220				alc883_targa_verbs},
10221		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10222		.dac_nids = alc883_dac_nids,
10223		.adc_nids = alc883_adc_nids_alt,
10224		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10225		.capsrc_nids = alc883_capsrc_nids,
10226		.dig_out_nid = ALC883_DIGOUT_NID,
10227		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10228		.channel_mode = alc883_3ST_2ch_modes,
10229		.input_mux = &alc883_capture_source,
10230		.unsol_event = alc883_targa_unsol_event,
10231		.setup = alc882_targa_setup,
10232		.init_hook = alc882_targa_automute,
10233	},
10234	[ALC883_TARGA_8ch_DIG] = {
10235		.mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10236			    alc883_chmode_mixer },
10237		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10238				alc883_targa_verbs },
10239		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10240		.dac_nids = alc883_dac_nids,
10241		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10242		.adc_nids = alc883_adc_nids_rev,
10243		.capsrc_nids = alc883_capsrc_nids_rev,
10244		.dig_out_nid = ALC883_DIGOUT_NID,
10245		.dig_in_nid = ALC883_DIGIN_NID,
10246		.num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10247		.channel_mode = alc883_4ST_8ch_modes,
10248		.need_dac_fix = 1,
10249		.input_mux = &alc883_capture_source,
10250		.unsol_event = alc883_targa_unsol_event,
10251		.setup = alc882_targa_setup,
10252		.init_hook = alc882_targa_automute,
10253	},
10254	[ALC883_ACER] = {
10255		.mixers = { alc883_base_mixer },
10256		/* On TravelMate laptops, GPIO 0 enables the internal speaker
10257		 * and the headphone jack.  Turn this on and rely on the
10258		 * standard mute methods whenever the user wants to turn
10259		 * these outputs off.
10260		 */
10261		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10262		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10263		.dac_nids = alc883_dac_nids,
10264		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10265		.channel_mode = alc883_3ST_2ch_modes,
10266		.input_mux = &alc883_capture_source,
10267	},
10268	[ALC883_ACER_ASPIRE] = {
10269		.mixers = { alc883_acer_aspire_mixer },
10270		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10271		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10272		.dac_nids = alc883_dac_nids,
10273		.dig_out_nid = ALC883_DIGOUT_NID,
10274		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10275		.channel_mode = alc883_3ST_2ch_modes,
10276		.input_mux = &alc883_capture_source,
10277		.unsol_event = alc_automute_amp_unsol_event,
10278		.setup = alc883_acer_aspire_setup,
10279		.init_hook = alc_automute_amp,
10280	},
10281	[ALC888_ACER_ASPIRE_4930G] = {
10282		.mixers = { alc888_base_mixer,
10283				alc883_chmode_mixer },
10284		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10285				alc888_acer_aspire_4930g_verbs },
10286		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10287		.dac_nids = alc883_dac_nids,
10288		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10289		.adc_nids = alc883_adc_nids_rev,
10290		.capsrc_nids = alc883_capsrc_nids_rev,
10291		.dig_out_nid = ALC883_DIGOUT_NID,
10292		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10293		.channel_mode = alc883_3ST_6ch_modes,
10294		.need_dac_fix = 1,
10295		.const_channel_count = 6,
10296		.num_mux_defs =
10297			ARRAY_SIZE(alc888_2_capture_sources),
10298		.input_mux = alc888_2_capture_sources,
10299		.unsol_event = alc_automute_amp_unsol_event,
10300		.setup = alc888_acer_aspire_4930g_setup,
10301		.init_hook = alc_automute_amp,
10302	},
10303	[ALC888_ACER_ASPIRE_6530G] = {
10304		.mixers = { alc888_acer_aspire_6530_mixer },
10305		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10306				alc888_acer_aspire_6530g_verbs },
10307		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10308		.dac_nids = alc883_dac_nids,
10309		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10310		.adc_nids = alc883_adc_nids_rev,
10311		.capsrc_nids = alc883_capsrc_nids_rev,
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		.num_mux_defs =
10316			ARRAY_SIZE(alc888_2_capture_sources),
10317		.input_mux = alc888_acer_aspire_6530_sources,
10318		.unsol_event = alc_automute_amp_unsol_event,
10319		.setup = alc888_acer_aspire_6530g_setup,
10320		.init_hook = alc_automute_amp,
10321	},
10322	[ALC888_ACER_ASPIRE_8930G] = {
10323		.mixers = { alc889_acer_aspire_8930g_mixer,
10324				alc883_chmode_mixer },
10325		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10326				alc889_acer_aspire_8930g_verbs,
10327				alc889_eapd_verbs},
10328		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10329		.dac_nids = alc883_dac_nids,
10330		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10331		.adc_nids = alc889_adc_nids,
10332		.capsrc_nids = alc889_capsrc_nids,
10333		.dig_out_nid = ALC883_DIGOUT_NID,
10334		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10335		.channel_mode = alc883_3ST_6ch_modes,
10336		.need_dac_fix = 1,
10337		.const_channel_count = 6,
10338		.num_mux_defs =
10339			ARRAY_SIZE(alc889_capture_sources),
10340		.input_mux = alc889_capture_sources,
10341		.unsol_event = alc_automute_amp_unsol_event,
10342		.setup = alc889_acer_aspire_8930g_setup,
10343		.init_hook = alc_automute_amp,
10344#ifdef CONFIG_SND_HDA_POWER_SAVE
10345		.power_hook = alc_power_eapd,
10346#endif
10347	},
10348	[ALC888_ACER_ASPIRE_7730G] = {
10349		.mixers = { alc883_3ST_6ch_mixer,
10350				alc883_chmode_mixer },
10351		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10352				alc888_acer_aspire_7730G_verbs },
10353		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10354		.dac_nids = alc883_dac_nids,
10355		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10356		.adc_nids = alc883_adc_nids_rev,
10357		.capsrc_nids = alc883_capsrc_nids_rev,
10358		.dig_out_nid = ALC883_DIGOUT_NID,
10359		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10360		.channel_mode = alc883_3ST_6ch_modes,
10361		.need_dac_fix = 1,
10362		.const_channel_count = 6,
10363		.input_mux = &alc883_capture_source,
10364		.unsol_event = alc_automute_amp_unsol_event,
10365		.setup = alc888_acer_aspire_7730g_setup,
10366		.init_hook = alc_automute_amp,
10367	},
10368	[ALC883_MEDION] = {
10369		.mixers = { alc883_fivestack_mixer,
10370			    alc883_chmode_mixer },
10371		.init_verbs = { alc883_init_verbs,
10372				alc883_medion_eapd_verbs },
10373		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10374		.dac_nids = alc883_dac_nids,
10375		.adc_nids = alc883_adc_nids_alt,
10376		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10377		.capsrc_nids = alc883_capsrc_nids,
10378		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10379		.channel_mode = alc883_sixstack_modes,
10380		.input_mux = &alc883_capture_source,
10381	},
10382	[ALC883_MEDION_MD2] = {
10383		.mixers = { alc883_medion_md2_mixer},
10384		.init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
10385		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10386		.dac_nids = alc883_dac_nids,
10387		.dig_out_nid = ALC883_DIGOUT_NID,
10388		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10389		.channel_mode = alc883_3ST_2ch_modes,
10390		.input_mux = &alc883_capture_source,
10391		.unsol_event = alc_automute_amp_unsol_event,
10392		.setup = alc883_medion_md2_setup,
10393		.init_hook = alc_automute_amp,
10394	},
10395	[ALC883_MEDION_WIM2160] = {
10396		.mixers = { alc883_medion_wim2160_mixer },
10397		.init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10398		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10399		.dac_nids = alc883_dac_nids,
10400		.dig_out_nid = ALC883_DIGOUT_NID,
10401		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10402		.adc_nids = alc883_adc_nids,
10403		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10404		.channel_mode = alc883_3ST_2ch_modes,
10405		.input_mux = &alc883_capture_source,
10406		.unsol_event = alc_automute_amp_unsol_event,
10407		.setup = alc883_medion_wim2160_setup,
10408		.init_hook = alc_automute_amp,
10409	},
10410	[ALC883_LAPTOP_EAPD] = {
10411		.mixers = { alc883_base_mixer },
10412		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10413		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10414		.dac_nids = alc883_dac_nids,
10415		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10416		.channel_mode = alc883_3ST_2ch_modes,
10417		.input_mux = &alc883_capture_source,
10418	},
10419	[ALC883_CLEVO_M540R] = {
10420		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10421		.init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10422		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10423		.dac_nids = alc883_dac_nids,
10424		.dig_out_nid = ALC883_DIGOUT_NID,
10425		.dig_in_nid = ALC883_DIGIN_NID,
10426		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10427		.channel_mode = alc883_3ST_6ch_clevo_modes,
10428		.need_dac_fix = 1,
10429		.input_mux = &alc883_capture_source,
10430		/* This machine has the hardware HP auto-muting, thus
10431		 * we need no software mute via unsol event
10432		 */
10433	},
10434	[ALC883_CLEVO_M720] = {
10435		.mixers = { alc883_clevo_m720_mixer },
10436		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10437		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10438		.dac_nids = alc883_dac_nids,
10439		.dig_out_nid = ALC883_DIGOUT_NID,
10440		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10441		.channel_mode = alc883_3ST_2ch_modes,
10442		.input_mux = &alc883_capture_source,
10443		.unsol_event = alc883_clevo_m720_unsol_event,
10444		.setup = alc883_clevo_m720_setup,
10445		.init_hook = alc883_clevo_m720_init_hook,
10446	},
10447	[ALC883_LENOVO_101E_2ch] = {
10448		.mixers = { alc883_lenovo_101e_2ch_mixer},
10449		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10450		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10451		.dac_nids = alc883_dac_nids,
10452		.adc_nids = alc883_adc_nids_alt,
10453		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10454		.capsrc_nids = alc883_capsrc_nids,
10455		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10456		.channel_mode = alc883_3ST_2ch_modes,
10457		.input_mux = &alc883_lenovo_101e_capture_source,
10458		.unsol_event = alc883_lenovo_101e_unsol_event,
10459		.init_hook = alc883_lenovo_101e_all_automute,
10460	},
10461	[ALC883_LENOVO_NB0763] = {
10462		.mixers = { alc883_lenovo_nb0763_mixer },
10463		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10464		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10465		.dac_nids = alc883_dac_nids,
10466		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10467		.channel_mode = alc883_3ST_2ch_modes,
10468		.need_dac_fix = 1,
10469		.input_mux = &alc883_lenovo_nb0763_capture_source,
10470		.unsol_event = alc_automute_amp_unsol_event,
10471		.setup = alc883_medion_md2_setup,
10472		.init_hook = alc_automute_amp,
10473	},
10474	[ALC888_LENOVO_MS7195_DIG] = {
10475		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10476		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10477		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10478		.dac_nids = alc883_dac_nids,
10479		.dig_out_nid = ALC883_DIGOUT_NID,
10480		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10481		.channel_mode = alc883_3ST_6ch_modes,
10482		.need_dac_fix = 1,
10483		.input_mux = &alc883_capture_source,
10484		.unsol_event = alc883_lenovo_ms7195_unsol_event,
10485		.init_hook = alc888_lenovo_ms7195_front_automute,
10486	},
10487	[ALC883_HAIER_W66] = {
10488		.mixers = { alc883_targa_2ch_mixer},
10489		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10490		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10491		.dac_nids = alc883_dac_nids,
10492		.dig_out_nid = ALC883_DIGOUT_NID,
10493		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10494		.channel_mode = alc883_3ST_2ch_modes,
10495		.input_mux = &alc883_capture_source,
10496		.unsol_event = alc_automute_amp_unsol_event,
10497		.setup = alc883_haier_w66_setup,
10498		.init_hook = alc_automute_amp,
10499	},
10500	[ALC888_3ST_HP] = {
10501		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10502		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10503		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10504		.dac_nids = alc883_dac_nids,
10505		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10506		.channel_mode = alc888_3st_hp_modes,
10507		.need_dac_fix = 1,
10508		.input_mux = &alc883_capture_source,
10509		.unsol_event = alc_automute_amp_unsol_event,
10510		.setup = alc888_3st_hp_setup,
10511		.init_hook = alc_automute_amp,
10512	},
10513	[ALC888_6ST_DELL] = {
10514		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10515		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10516		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10517		.dac_nids = alc883_dac_nids,
10518		.dig_out_nid = ALC883_DIGOUT_NID,
10519		.dig_in_nid = ALC883_DIGIN_NID,
10520		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10521		.channel_mode = alc883_sixstack_modes,
10522		.input_mux = &alc883_capture_source,
10523		.unsol_event = alc_automute_amp_unsol_event,
10524		.setup = alc888_6st_dell_setup,
10525		.init_hook = alc_automute_amp,
10526	},
10527	[ALC883_MITAC] = {
10528		.mixers = { alc883_mitac_mixer },
10529		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10530		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10531		.dac_nids = alc883_dac_nids,
10532		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10533		.channel_mode = alc883_3ST_2ch_modes,
10534		.input_mux = &alc883_capture_source,
10535		.unsol_event = alc_automute_amp_unsol_event,
10536		.setup = alc883_mitac_setup,
10537		.init_hook = alc_automute_amp,
10538	},
10539	[ALC883_FUJITSU_PI2515] = {
10540		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10541		.init_verbs = { alc883_init_verbs,
10542				alc883_2ch_fujitsu_pi2515_verbs},
10543		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10544		.dac_nids = alc883_dac_nids,
10545		.dig_out_nid = ALC883_DIGOUT_NID,
10546		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10547		.channel_mode = alc883_3ST_2ch_modes,
10548		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10549		.unsol_event = alc_automute_amp_unsol_event,
10550		.setup = alc883_2ch_fujitsu_pi2515_setup,
10551		.init_hook = alc_automute_amp,
10552	},
10553	[ALC888_FUJITSU_XA3530] = {
10554		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
10555		.init_verbs = { alc883_init_verbs,
10556			alc888_fujitsu_xa3530_verbs },
10557		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10558		.dac_nids = alc883_dac_nids,
10559		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10560		.adc_nids = alc883_adc_nids_rev,
10561		.capsrc_nids = alc883_capsrc_nids_rev,
10562		.dig_out_nid = ALC883_DIGOUT_NID,
10563		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10564		.channel_mode = alc888_4ST_8ch_intel_modes,
10565		.num_mux_defs =
10566			ARRAY_SIZE(alc888_2_capture_sources),
10567		.input_mux = alc888_2_capture_sources,
10568		.unsol_event = alc_automute_amp_unsol_event,
10569		.setup = alc888_fujitsu_xa3530_setup,
10570		.init_hook = alc_automute_amp,
10571	},
10572	[ALC888_LENOVO_SKY] = {
10573		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10574		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10575		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10576		.dac_nids = alc883_dac_nids,
10577		.dig_out_nid = ALC883_DIGOUT_NID,
10578		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10579		.channel_mode = alc883_sixstack_modes,
10580		.need_dac_fix = 1,
10581		.input_mux = &alc883_lenovo_sky_capture_source,
10582		.unsol_event = alc_automute_amp_unsol_event,
10583		.setup = alc888_lenovo_sky_setup,
10584		.init_hook = alc_automute_amp,
10585	},
10586	[ALC888_ASUS_M90V] = {
10587		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10588		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10589		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10590		.dac_nids = alc883_dac_nids,
10591		.dig_out_nid = ALC883_DIGOUT_NID,
10592		.dig_in_nid = ALC883_DIGIN_NID,
10593		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10594		.channel_mode = alc883_3ST_6ch_modes,
10595		.need_dac_fix = 1,
10596		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10597		.unsol_event = alc_sku_unsol_event,
10598		.setup = alc883_mode2_setup,
10599		.init_hook = alc_inithook,
10600	},
10601	[ALC888_ASUS_EEE1601] = {
10602		.mixers = { alc883_asus_eee1601_mixer },
10603		.cap_mixer = alc883_asus_eee1601_cap_mixer,
10604		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10605		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10606		.dac_nids = alc883_dac_nids,
10607		.dig_out_nid = ALC883_DIGOUT_NID,
10608		.dig_in_nid = ALC883_DIGIN_NID,
10609		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10610		.channel_mode = alc883_3ST_2ch_modes,
10611		.need_dac_fix = 1,
10612		.input_mux = &alc883_asus_eee1601_capture_source,
10613		.unsol_event = alc_sku_unsol_event,
10614		.init_hook = alc883_eee1601_inithook,
10615	},
10616	[ALC1200_ASUS_P5Q] = {
10617		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10618		.init_verbs = { alc883_init_verbs },
10619		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10620		.dac_nids = alc883_dac_nids,
10621		.dig_out_nid = ALC1200_DIGOUT_NID,
10622		.dig_in_nid = ALC883_DIGIN_NID,
10623		.slave_dig_outs = alc1200_slave_dig_outs,
10624		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10625		.channel_mode = alc883_sixstack_modes,
10626		.input_mux = &alc883_capture_source,
10627	},
10628	[ALC889A_MB31] = {
10629		.mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10630		.init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10631			alc880_gpio1_init_verbs },
10632		.adc_nids = alc883_adc_nids,
10633		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10634		.capsrc_nids = alc883_capsrc_nids,
10635		.dac_nids = alc883_dac_nids,
10636		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10637		.channel_mode = alc889A_mb31_6ch_modes,
10638		.num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10639		.input_mux = &alc889A_mb31_capture_source,
10640		.dig_out_nid = ALC883_DIGOUT_NID,
10641		.unsol_event = alc889A_mb31_unsol_event,
10642		.init_hook = alc889A_mb31_automute,
10643	},
10644	[ALC883_SONY_VAIO_TT] = {
10645		.mixers = { alc883_vaiott_mixer },
10646		.init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10647		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10648		.dac_nids = alc883_dac_nids,
10649		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10650		.channel_mode = alc883_3ST_2ch_modes,
10651		.input_mux = &alc883_capture_source,
10652		.unsol_event = alc_automute_amp_unsol_event,
10653		.setup = alc883_vaiott_setup,
10654		.init_hook = alc_automute_amp,
10655	},
10656};
10657
10658
10659/*
10660 * Pin config fixes
10661 */
10662enum {
10663	PINFIX_ABIT_AW9D_MAX,
10664	PINFIX_PB_M5210,
10665	PINFIX_ACER_ASPIRE_7736,
10666};
10667
10668static const struct alc_fixup alc882_fixups[] = {
10669	[PINFIX_ABIT_AW9D_MAX] = {
10670		.pins = (const struct alc_pincfg[]) {
10671			{ 0x15, 0x01080104 }, /* side */
10672			{ 0x16, 0x01011012 }, /* rear */
10673			{ 0x17, 0x01016011 }, /* clfe */
10674			{ }
10675		}
10676	},
10677	[PINFIX_PB_M5210] = {
10678		.verbs = (const struct hda_verb[]) {
10679			{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10680			{}
10681		}
10682	},
10683	[PINFIX_ACER_ASPIRE_7736] = {
10684		.sku = ALC_FIXUP_SKU_IGNORE,
10685	},
10686};
10687
10688static struct snd_pci_quirk alc882_fixup_tbl[] = {
10689	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10690	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10691	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10692	{}
10693};
10694
10695/*
10696 * BIOS auto configuration
10697 */
10698static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10699						const struct auto_pin_cfg *cfg)
10700{
10701	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10702}
10703
10704static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10705					      hda_nid_t nid, int pin_type,
10706					      hda_nid_t dac)
10707{
10708	int idx;
10709
10710	/* set as output */
10711	alc_set_pin_output(codec, nid, pin_type);
10712
10713	if (dac == 0x25)
10714		idx = 4;
10715	else if (dac >= 0x02 && dac <= 0x05)
10716		idx = dac - 2;
10717	else
10718		return;
10719	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10720}
10721
10722static void alc882_auto_init_multi_out(struct hda_codec *codec)
10723{
10724	struct alc_spec *spec = codec->spec;
10725	int i;
10726
10727	for (i = 0; i <= HDA_SIDE; i++) {
10728		hda_nid_t nid = spec->autocfg.line_out_pins[i];
10729		int pin_type = get_pin_type(spec->autocfg.line_out_type);
10730		if (nid)
10731			alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10732					spec->multiout.dac_nids[i]);
10733	}
10734}
10735
10736static void alc882_auto_init_hp_out(struct hda_codec *codec)
10737{
10738	struct alc_spec *spec = codec->spec;
10739	hda_nid_t pin, dac;
10740	int i;
10741
10742	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10743		pin = spec->autocfg.hp_pins[i];
10744		if (!pin)
10745			break;
10746		dac = spec->multiout.hp_nid;
10747		if (!dac)
10748			dac = spec->multiout.dac_nids[0]; /* to front */
10749		alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10750	}
10751	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10752		pin = spec->autocfg.speaker_pins[i];
10753		if (!pin)
10754			break;
10755		dac = spec->multiout.extra_out_nid[0];
10756		if (!dac)
10757			dac = spec->multiout.dac_nids[0]; /* to front */
10758		alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10759	}
10760}
10761
10762static void alc882_auto_init_analog_input(struct hda_codec *codec)
10763{
10764	struct alc_spec *spec = codec->spec;
10765	struct auto_pin_cfg *cfg = &spec->autocfg;
10766	int i;
10767
10768	for (i = 0; i < cfg->num_inputs; i++) {
10769		hda_nid_t nid = cfg->inputs[i].pin;
10770		alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10771		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10772			snd_hda_codec_write(codec, nid, 0,
10773					    AC_VERB_SET_AMP_GAIN_MUTE,
10774					    AMP_OUT_MUTE);
10775	}
10776}
10777
10778static void alc882_auto_init_input_src(struct hda_codec *codec)
10779{
10780	struct alc_spec *spec = codec->spec;
10781	int c;
10782
10783	for (c = 0; c < spec->num_adc_nids; c++) {
10784		hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10785		hda_nid_t nid = spec->capsrc_nids[c];
10786		unsigned int mux_idx;
10787		const struct hda_input_mux *imux;
10788		int conns, mute, idx, item;
10789
10790		conns = snd_hda_get_connections(codec, nid, conn_list,
10791						ARRAY_SIZE(conn_list));
10792		if (conns < 0)
10793			continue;
10794		mux_idx = c >= spec->num_mux_defs ? 0 : c;
10795		imux = &spec->input_mux[mux_idx];
10796		if (!imux->num_items && mux_idx > 0)
10797			imux = &spec->input_mux[0];
10798		for (idx = 0; idx < conns; idx++) {
10799			/* if the current connection is the selected one,
10800			 * unmute it as default - otherwise mute it
10801			 */
10802			mute = AMP_IN_MUTE(idx);
10803			for (item = 0; item < imux->num_items; item++) {
10804				if (imux->items[item].index == idx) {
10805					if (spec->cur_mux[c] == item)
10806						mute = AMP_IN_UNMUTE(idx);
10807					break;
10808				}
10809			}
10810			/* check if we have a selector or mixer
10811			 * we could check for the widget type instead, but
10812			 * just check for Amp-In presence (in case of mixer
10813			 * without amp-in there is something wrong, this
10814			 * function shouldn't be used or capsrc nid is wrong)
10815			 */
10816			if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10817				snd_hda_codec_write(codec, nid, 0,
10818						    AC_VERB_SET_AMP_GAIN_MUTE,
10819						    mute);
10820			else if (mute != AMP_IN_MUTE(idx))
10821				snd_hda_codec_write(codec, nid, 0,
10822						    AC_VERB_SET_CONNECT_SEL,
10823						    idx);
10824		}
10825	}
10826}
10827
10828/* add mic boosts if needed */
10829static int alc_auto_add_mic_boost(struct hda_codec *codec)
10830{
10831	struct alc_spec *spec = codec->spec;
10832	struct auto_pin_cfg *cfg = &spec->autocfg;
10833	int i, err, type;
10834	int type_idx = 0;
10835	hda_nid_t nid;
10836
10837	for (i = 0; i < cfg->num_inputs; i++) {
10838		if (cfg->inputs[i].type > AUTO_PIN_MIC)
10839			break;
10840		nid = cfg->inputs[i].pin;
10841		if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10842			char label[32];
10843			type = cfg->inputs[i].type;
10844			if (i > 0 && type == cfg->inputs[i - 1].type)
10845				type_idx++;
10846			else
10847				type_idx = 0;
10848			snprintf(label, sizeof(label), "%s Boost",
10849				 hda_get_autocfg_input_label(codec, cfg, i));
10850			err = add_control(spec, ALC_CTL_WIDGET_VOL, label,
10851					  type_idx,
10852				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10853			if (err < 0)
10854				return err;
10855		}
10856	}
10857	return 0;
10858}
10859
10860/* almost identical with ALC880 parser... */
10861static int alc882_parse_auto_config(struct hda_codec *codec)
10862{
10863	struct alc_spec *spec = codec->spec;
10864	static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10865	int err;
10866
10867	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10868					   alc882_ignore);
10869	if (err < 0)
10870		return err;
10871	if (!spec->autocfg.line_outs)
10872		return 0; /* can't find valid BIOS pin config */
10873
10874	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10875	if (err < 0)
10876		return err;
10877	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10878	if (err < 0)
10879		return err;
10880	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10881					   "Headphone");
10882	if (err < 0)
10883		return err;
10884	err = alc880_auto_create_extra_out(spec,
10885					   spec->autocfg.speaker_pins[0],
10886					   "Speaker");
10887	if (err < 0)
10888		return err;
10889	err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10890	if (err < 0)
10891		return err;
10892
10893	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10894
10895	alc_auto_parse_digital(codec);
10896
10897	if (spec->kctls.list)
10898		add_mixer(spec, spec->kctls.list);
10899
10900	add_verb(spec, alc883_auto_init_verbs);
10901	/* if ADC 0x07 is available, initialize it, too */
10902	if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10903		add_verb(spec, alc882_adc1_init_verbs);
10904
10905	spec->num_mux_defs = 1;
10906	spec->input_mux = &spec->private_imux[0];
10907
10908	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10909
10910	err = alc_auto_add_mic_boost(codec);
10911	if (err < 0)
10912		return err;
10913
10914	return 1; /* config found */
10915}
10916
10917/* additional initialization for auto-configuration model */
10918static void alc882_auto_init(struct hda_codec *codec)
10919{
10920	struct alc_spec *spec = codec->spec;
10921	alc882_auto_init_multi_out(codec);
10922	alc882_auto_init_hp_out(codec);
10923	alc882_auto_init_analog_input(codec);
10924	alc882_auto_init_input_src(codec);
10925	alc_auto_init_digital(codec);
10926	if (spec->unsol_event)
10927		alc_inithook(codec);
10928}
10929
10930static int patch_alc882(struct hda_codec *codec)
10931{
10932	struct alc_spec *spec;
10933	int err, board_config;
10934
10935	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10936	if (spec == NULL)
10937		return -ENOMEM;
10938
10939	codec->spec = spec;
10940
10941	switch (codec->vendor_id) {
10942	case 0x10ec0882:
10943	case 0x10ec0885:
10944		break;
10945	default:
10946		/* ALC883 and variants */
10947		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10948		break;
10949	}
10950
10951	board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10952						  alc882_models,
10953						  alc882_cfg_tbl);
10954
10955	if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10956		board_config = snd_hda_check_board_codec_sid_config(codec,
10957			ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10958
10959	if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10960		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10961		       codec->chip_name);
10962		board_config = ALC882_AUTO;
10963	}
10964
10965	if (board_config == ALC882_AUTO)
10966		alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10967
10968	alc_auto_parse_customize_define(codec);
10969
10970	if (board_config == ALC882_AUTO) {
10971		/* automatic parse from the BIOS config */
10972		err = alc882_parse_auto_config(codec);
10973		if (err < 0) {
10974			alc_free(codec);
10975			return err;
10976		} else if (!err) {
10977			printk(KERN_INFO
10978			       "hda_codec: Cannot set up configuration "
10979			       "from BIOS.  Using base mode...\n");
10980			board_config = ALC882_3ST_DIG;
10981		}
10982	}
10983
10984	if (has_cdefine_beep(codec)) {
10985		err = snd_hda_attach_beep_device(codec, 0x1);
10986		if (err < 0) {
10987			alc_free(codec);
10988			return err;
10989		}
10990	}
10991
10992	if (board_config != ALC882_AUTO)
10993		setup_preset(codec, &alc882_presets[board_config]);
10994
10995	spec->stream_analog_playback = &alc882_pcm_analog_playback;
10996	spec->stream_analog_capture = &alc882_pcm_analog_capture;
10997	/* FIXME: setup DAC5 */
10998	/*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10999	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11000
11001	spec->stream_digital_playback = &alc882_pcm_digital_playback;
11002	spec->stream_digital_capture = &alc882_pcm_digital_capture;
11003
11004	if (!spec->adc_nids && spec->input_mux) {
11005		int i, j;
11006		spec->num_adc_nids = 0;
11007		for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11008			const struct hda_input_mux *imux = spec->input_mux;
11009			hda_nid_t cap;
11010			hda_nid_t items[16];
11011			hda_nid_t nid = alc882_adc_nids[i];
11012			unsigned int wcap = get_wcaps(codec, nid);
11013			/* get type */
11014			wcap = get_wcaps_type(wcap);
11015			if (wcap != AC_WID_AUD_IN)
11016				continue;
11017			spec->private_adc_nids[spec->num_adc_nids] = nid;
11018			err = snd_hda_get_connections(codec, nid, &cap, 1);
11019			if (err < 0)
11020				continue;
11021			err = snd_hda_get_connections(codec, cap, items,
11022						      ARRAY_SIZE(items));
11023			if (err < 0)
11024				continue;
11025			for (j = 0; j < imux->num_items; j++)
11026				if (imux->items[j].index >= err)
11027					break;
11028			if (j < imux->num_items)
11029				continue;
11030			spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11031			spec->num_adc_nids++;
11032		}
11033		spec->adc_nids = spec->private_adc_nids;
11034		spec->capsrc_nids = spec->private_capsrc_nids;
11035	}
11036
11037	set_capture_mixer(codec);
11038
11039	if (has_cdefine_beep(codec))
11040		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11041
11042	if (board_config == ALC882_AUTO)
11043		alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
11044
11045	spec->vmaster_nid = 0x0c;
11046
11047	codec->patch_ops = alc_patch_ops;
11048	if (board_config == ALC882_AUTO)
11049		spec->init_hook = alc882_auto_init;
11050
11051	alc_init_jacks(codec);
11052#ifdef CONFIG_SND_HDA_POWER_SAVE
11053	if (!spec->loopback.amplist)
11054		spec->loopback.amplist = alc882_loopbacks;
11055#endif
11056
11057	return 0;
11058}
11059
11060
11061/*
11062 * ALC262 support
11063 */
11064
11065#define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
11066#define ALC262_DIGIN_NID	ALC880_DIGIN_NID
11067
11068#define alc262_dac_nids		alc260_dac_nids
11069#define alc262_adc_nids		alc882_adc_nids
11070#define alc262_adc_nids_alt	alc882_adc_nids_alt
11071#define alc262_capsrc_nids	alc882_capsrc_nids
11072#define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
11073
11074#define alc262_modes		alc260_modes
11075#define alc262_capture_source	alc882_capture_source
11076
11077static hda_nid_t alc262_dmic_adc_nids[1] = {
11078	/* ADC0 */
11079	0x09
11080};
11081
11082static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11083
11084static struct snd_kcontrol_new alc262_base_mixer[] = {
11085	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11086	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11087	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11088	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11089	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11090	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11091	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11092	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11093	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11094	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11095	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11096	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11097	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11098	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11099	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11100	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11101	{ } /* end */
11102};
11103
11104/* update HP, line and mono-out pins according to the master switch */
11105static void alc262_hp_master_update(struct hda_codec *codec)
11106{
11107	struct alc_spec *spec = codec->spec;
11108	int val = spec->master_sw;
11109
11110	/* HP & line-out */
11111	snd_hda_codec_write_cache(codec, 0x1b, 0,
11112				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11113				  val ? PIN_HP : 0);
11114	snd_hda_codec_write_cache(codec, 0x15, 0,
11115				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11116				  val ? PIN_HP : 0);
11117	/* mono (speaker) depending on the HP jack sense */
11118	val = val && !spec->jack_present;
11119	snd_hda_codec_write_cache(codec, 0x16, 0,
11120				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11121				  val ? PIN_OUT : 0);
11122}
11123
11124static void alc262_hp_bpc_automute(struct hda_codec *codec)
11125{
11126	struct alc_spec *spec = codec->spec;
11127
11128	spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11129	alc262_hp_master_update(codec);
11130}
11131
11132static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11133{
11134	if ((res >> 26) != ALC880_HP_EVENT)
11135		return;
11136	alc262_hp_bpc_automute(codec);
11137}
11138
11139static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11140{
11141	struct alc_spec *spec = codec->spec;
11142
11143	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11144	alc262_hp_master_update(codec);
11145}
11146
11147static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11148					   unsigned int res)
11149{
11150	if ((res >> 26) != ALC880_HP_EVENT)
11151		return;
11152	alc262_hp_wildwest_automute(codec);
11153}
11154
11155#define alc262_hp_master_sw_get		alc260_hp_master_sw_get
11156
11157static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11158				   struct snd_ctl_elem_value *ucontrol)
11159{
11160	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11161	struct alc_spec *spec = codec->spec;
11162	int val = !!*ucontrol->value.integer.value;
11163
11164	if (val == spec->master_sw)
11165		return 0;
11166	spec->master_sw = val;
11167	alc262_hp_master_update(codec);
11168	return 1;
11169}
11170
11171#define ALC262_HP_MASTER_SWITCH					\
11172	{							\
11173		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
11174		.name = "Master Playback Switch",		\
11175		.info = snd_ctl_boolean_mono_info,		\
11176		.get = alc262_hp_master_sw_get,			\
11177		.put = alc262_hp_master_sw_put,			\
11178	}, \
11179	{							\
11180		.iface = NID_MAPPING,				\
11181		.name = "Master Playback Switch",		\
11182		.private_value = 0x15 | (0x16 << 8) | (0x1b << 16),	\
11183	}
11184
11185
11186static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11187	ALC262_HP_MASTER_SWITCH,
11188	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11189	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11190	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11191	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11192			      HDA_OUTPUT),
11193	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11194			    HDA_OUTPUT),
11195	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11196	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11197	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11198	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11199	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11200	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11201	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11202	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11203	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11204	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11205	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11206	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11207	{ } /* end */
11208};
11209
11210static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11211	ALC262_HP_MASTER_SWITCH,
11212	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11213	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11214	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11215	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11216	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11217			      HDA_OUTPUT),
11218	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11219			    HDA_OUTPUT),
11220	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11221	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11222	HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
11223	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11224	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11225	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11226	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11227	{ } /* end */
11228};
11229
11230static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11231	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11232	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11233	HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
11234	{ } /* end */
11235};
11236
11237/* mute/unmute internal speaker according to the hp jack and mute state */
11238static void alc262_hp_t5735_setup(struct hda_codec *codec)
11239{
11240	struct alc_spec *spec = codec->spec;
11241
11242	spec->autocfg.hp_pins[0] = 0x15;
11243	spec->autocfg.speaker_pins[0] = 0x14;
11244}
11245
11246static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11247	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11248	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11249	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11250	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11251	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11252	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11253	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11254	{ } /* end */
11255};
11256
11257static struct hda_verb alc262_hp_t5735_verbs[] = {
11258	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11259	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11260
11261	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11262	{ }
11263};
11264
11265static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11266	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11267	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11268	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11269	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11270	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11271	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11272	{ } /* end */
11273};
11274
11275static struct hda_verb alc262_hp_rp5700_verbs[] = {
11276	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11277	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11278	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11279	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11280	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11281	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11282	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11283	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11284	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11285	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11286	{}
11287};
11288
11289static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11290	.num_items = 1,
11291	.items = {
11292		{ "Line", 0x1 },
11293	},
11294};
11295
11296/* bind hp and internal speaker mute (with plug check) as master switch */
11297static void alc262_hippo_master_update(struct hda_codec *codec)
11298{
11299	struct alc_spec *spec = codec->spec;
11300	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11301	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11302	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11303	unsigned int mute;
11304
11305	/* HP */
11306	mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11307	snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11308				 HDA_AMP_MUTE, mute);
11309	/* mute internal speaker per jack sense */
11310	if (spec->jack_present)
11311		mute = HDA_AMP_MUTE;
11312	if (line_nid)
11313		snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11314					 HDA_AMP_MUTE, mute);
11315	if (speaker_nid && speaker_nid != line_nid)
11316		snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11317					 HDA_AMP_MUTE, mute);
11318}
11319
11320#define alc262_hippo_master_sw_get	alc262_hp_master_sw_get
11321
11322static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11323				      struct snd_ctl_elem_value *ucontrol)
11324{
11325	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11326	struct alc_spec *spec = codec->spec;
11327	int val = !!*ucontrol->value.integer.value;
11328
11329	if (val == spec->master_sw)
11330		return 0;
11331	spec->master_sw = val;
11332	alc262_hippo_master_update(codec);
11333	return 1;
11334}
11335
11336#define ALC262_HIPPO_MASTER_SWITCH				\
11337	{							\
11338		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
11339		.name = "Master Playback Switch",		\
11340		.info = snd_ctl_boolean_mono_info,		\
11341		.get = alc262_hippo_master_sw_get,		\
11342		.put = alc262_hippo_master_sw_put,		\
11343	},							\
11344	{							\
11345		.iface = NID_MAPPING,				\
11346		.name = "Master Playback Switch",		\
11347		.subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11348			     (SUBDEV_SPEAKER(0) << 16), \
11349	}
11350
11351static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11352	ALC262_HIPPO_MASTER_SWITCH,
11353	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11354	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11355	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11356	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11357	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11358	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11359	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11360	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11361	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11362	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11363	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11364	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11365	{ } /* end */
11366};
11367
11368static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11369	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11370	ALC262_HIPPO_MASTER_SWITCH,
11371	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11372	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11373	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11374	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11375	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11376	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11377	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11378	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11379	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11380	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11381	{ } /* end */
11382};
11383
11384/* mute/unmute internal speaker according to the hp jack and mute state */
11385static void alc262_hippo_automute(struct hda_codec *codec)
11386{
11387	struct alc_spec *spec = codec->spec;
11388	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11389
11390	spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11391	alc262_hippo_master_update(codec);
11392}
11393
11394static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11395{
11396	if ((res >> 26) != ALC880_HP_EVENT)
11397		return;
11398	alc262_hippo_automute(codec);
11399}
11400
11401static void alc262_hippo_setup(struct hda_codec *codec)
11402{
11403	struct alc_spec *spec = codec->spec;
11404
11405	spec->autocfg.hp_pins[0] = 0x15;
11406	spec->autocfg.speaker_pins[0] = 0x14;
11407}
11408
11409static void alc262_hippo1_setup(struct hda_codec *codec)
11410{
11411	struct alc_spec *spec = codec->spec;
11412
11413	spec->autocfg.hp_pins[0] = 0x1b;
11414	spec->autocfg.speaker_pins[0] = 0x14;
11415}
11416
11417
11418static struct snd_kcontrol_new alc262_sony_mixer[] = {
11419	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11420	ALC262_HIPPO_MASTER_SWITCH,
11421	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11422	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11423	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11424	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11425	{ } /* end */
11426};
11427
11428static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11429	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11430	ALC262_HIPPO_MASTER_SWITCH,
11431	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11432	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11433	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11434	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11435	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11436	{ } /* end */
11437};
11438
11439static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11440	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11441	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11442	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11443	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11444	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11445	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11446	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11447	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11448	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11449	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11450	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11451	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11452	{ } /* end */
11453};
11454
11455static struct hda_verb alc262_tyan_verbs[] = {
11456	/* Headphone automute */
11457	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11458	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11459	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11460
11461	/* P11 AUX_IN, white 4-pin connector */
11462	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11463	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11464	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11465	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11466
11467	{}
11468};
11469
11470/* unsolicited event for HP jack sensing */
11471static void alc262_tyan_setup(struct hda_codec *codec)
11472{
11473	struct alc_spec *spec = codec->spec;
11474
11475	spec->autocfg.hp_pins[0] = 0x1b;
11476	spec->autocfg.speaker_pins[0] = 0x15;
11477}
11478
11479
11480#define alc262_capture_mixer		alc882_capture_mixer
11481#define alc262_capture_alt_mixer	alc882_capture_alt_mixer
11482
11483/*
11484 * generic initialization of ADC, input mixers and output mixers
11485 */
11486static struct hda_verb alc262_init_verbs[] = {
11487	/*
11488	 * Unmute ADC0-2 and set the default input to mic-in
11489	 */
11490	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11491	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11492	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11493	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11494	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11495	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11496
11497	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11498	 * mixer widget
11499	 * Note: PASD motherboards uses the Line In 2 as the input for
11500	 * front panel mic (mic 2)
11501	 */
11502	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11503	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11504	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11505	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11506	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11507	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11508
11509	/*
11510	 * Set up output mixers (0x0c - 0x0e)
11511	 */
11512	/* set vol=0 to output mixers */
11513	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11514	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11515	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11516	/* set up input amps for analog loopback */
11517	/* Amp Indices: DAC = 0, mixer = 1 */
11518	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11519	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11520	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11521	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11522	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11523	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11524
11525	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11526	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11527	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11528	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11529	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11530	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11531
11532	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11533	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11534	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11535	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11536	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11537
11538	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11539	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11540
11541	/* FIXME: use matrix-type input source selection */
11542	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11543	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11544	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11545	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11546	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11547	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11548	/* Input mixer2 */
11549	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11550	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11551	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11552	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11553	/* Input mixer3 */
11554	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11555	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11556	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11557	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11558
11559	{ }
11560};
11561
11562static struct hda_verb alc262_eapd_verbs[] = {
11563	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11564	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11565	{ }
11566};
11567
11568static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11569	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11570	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11571	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11572
11573	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11574	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11575	{}
11576};
11577
11578static struct hda_verb alc262_sony_unsol_verbs[] = {
11579	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11580	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11581	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
11582
11583	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11584	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11585	{}
11586};
11587
11588static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11589	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11590	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11591	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11592	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11593	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11594	{ } /* end */
11595};
11596
11597static struct hda_verb alc262_toshiba_s06_verbs[] = {
11598	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11599	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11600	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11601	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11602	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11603	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11604	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11605	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11606	{}
11607};
11608
11609static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11610{
11611	struct alc_spec *spec = codec->spec;
11612
11613	spec->autocfg.hp_pins[0] = 0x15;
11614	spec->autocfg.speaker_pins[0] = 0x14;
11615	spec->ext_mic.pin = 0x18;
11616	spec->ext_mic.mux_idx = 0;
11617	spec->int_mic.pin = 0x12;
11618	spec->int_mic.mux_idx = 9;
11619	spec->auto_mic = 1;
11620}
11621
11622/*
11623 * nec model
11624 *  0x15 = headphone
11625 *  0x16 = internal speaker
11626 *  0x18 = external mic
11627 */
11628
11629static struct snd_kcontrol_new alc262_nec_mixer[] = {
11630	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11631	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11632
11633	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11634	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11635	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11636
11637	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11638	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11639	{ } /* end */
11640};
11641
11642static struct hda_verb alc262_nec_verbs[] = {
11643	/* Unmute Speaker */
11644	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11645
11646	/* Headphone */
11647	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11648	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11649
11650	/* External mic to headphone */
11651	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11652	/* External mic to speaker */
11653	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11654	{}
11655};
11656
11657/*
11658 * fujitsu model
11659 *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11660 *  0x1b = port replicator headphone out
11661 */
11662
11663#define ALC_HP_EVENT	0x37
11664
11665static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11666	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11667	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11668	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11669	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11670	{}
11671};
11672
11673static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11674	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11675	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11676	{}
11677};
11678
11679static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11680	/* Front Mic pin: input vref at 50% */
11681	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11682	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11683	{}
11684};
11685
11686static struct hda_input_mux alc262_fujitsu_capture_source = {
11687	.num_items = 3,
11688	.items = {
11689		{ "Mic", 0x0 },
11690		{ "Int Mic", 0x1 },
11691		{ "CD", 0x4 },
11692	},
11693};
11694
11695static struct hda_input_mux alc262_HP_capture_source = {
11696	.num_items = 5,
11697	.items = {
11698		{ "Mic", 0x0 },
11699		{ "Front Mic", 0x1 },
11700		{ "Line", 0x2 },
11701		{ "CD", 0x4 },
11702		{ "AUX IN", 0x6 },
11703	},
11704};
11705
11706static struct hda_input_mux alc262_HP_D7000_capture_source = {
11707	.num_items = 4,
11708	.items = {
11709		{ "Mic", 0x0 },
11710		{ "Front Mic", 0x2 },
11711		{ "Line", 0x1 },
11712		{ "CD", 0x4 },
11713	},
11714};
11715
11716/* mute/unmute internal speaker according to the hp jacks and mute state */
11717static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11718{
11719	struct alc_spec *spec = codec->spec;
11720	unsigned int mute;
11721
11722	if (force || !spec->sense_updated) {
11723		spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11724				     snd_hda_jack_detect(codec, 0x1b);
11725		spec->sense_updated = 1;
11726	}
11727	/* unmute internal speaker only if both HPs are unplugged and
11728	 * master switch is on
11729	 */
11730	if (spec->jack_present)
11731		mute = HDA_AMP_MUTE;
11732	else
11733		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11734	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11735				 HDA_AMP_MUTE, mute);
11736}
11737
11738/* unsolicited event for HP jack sensing */
11739static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11740				       unsigned int res)
11741{
11742	if ((res >> 26) != ALC_HP_EVENT)
11743		return;
11744	alc262_fujitsu_automute(codec, 1);
11745}
11746
11747static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11748{
11749	alc262_fujitsu_automute(codec, 1);
11750}
11751
11752/* bind volumes of both NID 0x0c and 0x0d */
11753static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11754	.ops = &snd_hda_bind_vol,
11755	.values = {
11756		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11757		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11758		0
11759	},
11760};
11761
11762/* mute/unmute internal speaker according to the hp jack and mute state */
11763static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11764{
11765	struct alc_spec *spec = codec->spec;
11766	unsigned int mute;
11767
11768	if (force || !spec->sense_updated) {
11769		spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11770		spec->sense_updated = 1;
11771	}
11772	if (spec->jack_present) {
11773		/* mute internal speaker */
11774		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11775					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11776		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11777					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11778	} else {
11779		/* unmute internal speaker if necessary */
11780		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11781		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11782					 HDA_AMP_MUTE, mute);
11783		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11784					 HDA_AMP_MUTE, mute);
11785	}
11786}
11787
11788/* unsolicited event for HP jack sensing */
11789static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11790				       unsigned int res)
11791{
11792	if ((res >> 26) != ALC_HP_EVENT)
11793		return;
11794	alc262_lenovo_3000_automute(codec, 1);
11795}
11796
11797static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11798				  int dir, int idx, long *valp)
11799{
11800	int i, change = 0;
11801
11802	for (i = 0; i < 2; i++, valp++)
11803		change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11804						   HDA_AMP_MUTE,
11805						   *valp ? 0 : HDA_AMP_MUTE);
11806	return change;
11807}
11808
11809/* bind hp and internal speaker mute (with plug check) */
11810static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11811					 struct snd_ctl_elem_value *ucontrol)
11812{
11813	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11814	long *valp = ucontrol->value.integer.value;
11815	int change;
11816
11817	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11818	change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11819	if (change)
11820		alc262_fujitsu_automute(codec, 0);
11821	return change;
11822}
11823
11824static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11825	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11826	{
11827		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11828		.name = "Master Playback Switch",
11829		.subdevice = HDA_SUBDEV_AMP_FLAG,
11830		.info = snd_hda_mixer_amp_switch_info,
11831		.get = snd_hda_mixer_amp_switch_get,
11832		.put = alc262_fujitsu_master_sw_put,
11833		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11834	},
11835	{
11836		.iface = NID_MAPPING,
11837		.name = "Master Playback Switch",
11838		.private_value = 0x1b,
11839	},
11840	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11841	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11842	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11843	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11844	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11845	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11846	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11847	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11848	{ } /* end */
11849};
11850
11851/* bind hp and internal speaker mute (with plug check) */
11852static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11853					 struct snd_ctl_elem_value *ucontrol)
11854{
11855	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11856	long *valp = ucontrol->value.integer.value;
11857	int change;
11858
11859	change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11860	if (change)
11861		alc262_lenovo_3000_automute(codec, 0);
11862	return change;
11863}
11864
11865static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11866	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11867	{
11868		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11869		.name = "Master Playback Switch",
11870		.subdevice = HDA_SUBDEV_AMP_FLAG,
11871		.info = snd_hda_mixer_amp_switch_info,
11872		.get = snd_hda_mixer_amp_switch_get,
11873		.put = alc262_lenovo_3000_master_sw_put,
11874		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11875	},
11876	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11877	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11878	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11879	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11880	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11881	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11882	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11883	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11884	{ } /* end */
11885};
11886
11887static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11888	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11889	ALC262_HIPPO_MASTER_SWITCH,
11890	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11891	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11892	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11893	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11894	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11895	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11896	{ } /* end */
11897};
11898
11899/* additional init verbs for Benq laptops */
11900static struct hda_verb alc262_EAPD_verbs[] = {
11901	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11902	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11903	{}
11904};
11905
11906static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11907	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11908	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11909
11910	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11911	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11912	{}
11913};
11914
11915/* Samsung Q1 Ultra Vista model setup */
11916static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11917	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11918	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11919	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11920	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11921	HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11922	HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11923	{ } /* end */
11924};
11925
11926static struct hda_verb alc262_ultra_verbs[] = {
11927	/* output mixer */
11928	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11929	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11930	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11931	/* speaker */
11932	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11933	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11934	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11935	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11936	/* HP */
11937	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11938	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11939	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11940	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11941	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11942	/* internal mic */
11943	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11944	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11945	/* ADC, choose mic */
11946	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11947	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11948	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11949	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11950	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11951	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11952	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11953	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11954	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11955	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11956	{}
11957};
11958
11959/* mute/unmute internal speaker according to the hp jack and mute state */
11960static void alc262_ultra_automute(struct hda_codec *codec)
11961{
11962	struct alc_spec *spec = codec->spec;
11963	unsigned int mute;
11964
11965	mute = 0;
11966	/* auto-mute only when HP is used as HP */
11967	if (!spec->cur_mux[0]) {
11968		spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11969		if (spec->jack_present)
11970			mute = HDA_AMP_MUTE;
11971	}
11972	/* mute/unmute internal speaker */
11973	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11974				 HDA_AMP_MUTE, mute);
11975	/* mute/unmute HP */
11976	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11977				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11978}
11979
11980/* unsolicited event for HP jack sensing */
11981static void alc262_ultra_unsol_event(struct hda_codec *codec,
11982				       unsigned int res)
11983{
11984	if ((res >> 26) != ALC880_HP_EVENT)
11985		return;
11986	alc262_ultra_automute(codec);
11987}
11988
11989static struct hda_input_mux alc262_ultra_capture_source = {
11990	.num_items = 2,
11991	.items = {
11992		{ "Mic", 0x1 },
11993		{ "Headphone", 0x7 },
11994	},
11995};
11996
11997static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11998				     struct snd_ctl_elem_value *ucontrol)
11999{
12000	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12001	struct alc_spec *spec = codec->spec;
12002	int ret;
12003
12004	ret = alc_mux_enum_put(kcontrol, ucontrol);
12005	if (!ret)
12006		return 0;
12007	/* reprogram the HP pin as mic or HP according to the input source */
12008	snd_hda_codec_write_cache(codec, 0x15, 0,
12009				  AC_VERB_SET_PIN_WIDGET_CONTROL,
12010				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12011	alc262_ultra_automute(codec); /* mute/unmute HP */
12012	return ret;
12013}
12014
12015static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12016	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12017	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12018	{
12019		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12020		.name = "Capture Source",
12021		.info = alc_mux_enum_info,
12022		.get = alc_mux_enum_get,
12023		.put = alc262_ultra_mux_enum_put,
12024	},
12025	{
12026		.iface = NID_MAPPING,
12027		.name = "Capture Source",
12028		.private_value = 0x15,
12029	},
12030	{ } /* end */
12031};
12032
12033/* We use two mixers depending on the output pin; 0x16 is a mono output
12034 * and thus it's bound with a different mixer.
12035 * This function returns which mixer amp should be used.
12036 */
12037static int alc262_check_volbit(hda_nid_t nid)
12038{
12039	if (!nid)
12040		return 0;
12041	else if (nid == 0x16)
12042		return 2;
12043	else
12044		return 1;
12045}
12046
12047static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12048				  const char *pfx, int *vbits, int idx)
12049{
12050	unsigned long val;
12051	int vbit;
12052
12053	vbit = alc262_check_volbit(nid);
12054	if (!vbit)
12055		return 0;
12056	if (*vbits & vbit) /* a volume control for this mixer already there */
12057		return 0;
12058	*vbits |= vbit;
12059	if (vbit == 2)
12060		val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12061	else
12062		val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12063	return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12064}
12065
12066static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12067				 const char *pfx, int idx)
12068{
12069	unsigned long val;
12070
12071	if (!nid)
12072		return 0;
12073	if (nid == 0x16)
12074		val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12075	else
12076		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12077	return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12078}
12079
12080/* add playback controls from the parsed DAC table */
12081static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12082					     const struct auto_pin_cfg *cfg)
12083{
12084	const char *pfx;
12085	int vbits;
12086	int i, err;
12087
12088	spec->multiout.num_dacs = 1;	/* only use one dac */
12089	spec->multiout.dac_nids = spec->private_dac_nids;
12090	spec->multiout.dac_nids[0] = 2;
12091
12092	if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
12093		pfx = "Master";
12094	else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12095		pfx = "Speaker";
12096	else if (cfg->line_out_type == AUTO_PIN_HP_OUT)
12097		pfx = "Headphone";
12098	else
12099		pfx = "Front";
12100	for (i = 0; i < 2; i++) {
12101		err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12102		if (err < 0)
12103			return err;
12104		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12105			err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12106						    "Speaker", i);
12107			if (err < 0)
12108				return err;
12109		}
12110		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12111			err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12112						    "Headphone", i);
12113			if (err < 0)
12114				return err;
12115		}
12116	}
12117
12118	vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12119		alc262_check_volbit(cfg->speaker_pins[0]) |
12120		alc262_check_volbit(cfg->hp_pins[0]);
12121	if (vbits == 1 || vbits == 2)
12122		pfx = "Master"; /* only one mixer is used */
12123	vbits = 0;
12124	for (i = 0; i < 2; i++) {
12125		err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12126					     &vbits, i);
12127		if (err < 0)
12128			return err;
12129		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12130			err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12131						     "Speaker", &vbits, i);
12132			if (err < 0)
12133				return err;
12134		}
12135		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12136			err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12137						     "Headphone", &vbits, i);
12138			if (err < 0)
12139				return err;
12140		}
12141	}
12142	return 0;
12143}
12144
12145#define alc262_auto_create_input_ctls \
12146	alc882_auto_create_input_ctls
12147
12148/*
12149 * generic initialization of ADC, input mixers and output mixers
12150 */
12151static struct hda_verb alc262_volume_init_verbs[] = {
12152	/*
12153	 * Unmute ADC0-2 and set the default input to mic-in
12154	 */
12155	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12156	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12157	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12158	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12159	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12160	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12161
12162	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12163	 * mixer widget
12164	 * Note: PASD motherboards uses the Line In 2 as the input for
12165	 * front panel mic (mic 2)
12166	 */
12167	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12168	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12169	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12170	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12171	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12172	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12173
12174	/*
12175	 * Set up output mixers (0x0c - 0x0f)
12176	 */
12177	/* set vol=0 to output mixers */
12178	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12179	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12180	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12181
12182	/* set up input amps for analog loopback */
12183	/* Amp Indices: DAC = 0, mixer = 1 */
12184	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12185	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12186	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12187	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12188	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12189	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12190
12191	/* FIXME: use matrix-type input source selection */
12192	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12193	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12194	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12195	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12196	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12197	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12198	/* Input mixer2 */
12199	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12200	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12201	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12202	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12203	/* Input mixer3 */
12204	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12205	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12206	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12207	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12208
12209	{ }
12210};
12211
12212static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12213	/*
12214	 * Unmute ADC0-2 and set the default input to mic-in
12215	 */
12216	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12217	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12218	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12219	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12220	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12221	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12222
12223	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12224	 * mixer widget
12225	 * Note: PASD motherboards uses the Line In 2 as the input for
12226	 * front panel mic (mic 2)
12227	 */
12228	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12229	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12230	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12231	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12232	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12233	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12234	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12235        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12236
12237	/*
12238	 * Set up output mixers (0x0c - 0x0e)
12239	 */
12240	/* set vol=0 to output mixers */
12241	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12242	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12243	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12244
12245	/* set up input amps for analog loopback */
12246	/* Amp Indices: DAC = 0, mixer = 1 */
12247	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12248	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12249	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12250	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12251	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12252	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12253
12254	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12255	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12256	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12257
12258	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12259	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12260
12261	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12262	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12263
12264	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12265	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12266        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12267	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12268	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12269
12270	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12271	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12272        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12273	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12274	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12275	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12276
12277
12278	/* FIXME: use matrix-type input source selection */
12279	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12280	/* Input mixer1: only unmute Mic */
12281	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12282	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12283	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12284	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12285	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12286	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12287	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12288	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12289	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12290	/* Input mixer2 */
12291	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12292	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12293	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12294	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12295	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12296	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12297	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12298	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12299	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12300	/* Input mixer3 */
12301	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12302	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12303	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12304	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12305	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12306	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12307	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12308	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12309	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12310
12311	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12312
12313	{ }
12314};
12315
12316static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12317	/*
12318	 * Unmute ADC0-2 and set the default input to mic-in
12319	 */
12320	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12321	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12322	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12323	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12324	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12325	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12326
12327	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12328	 * mixer widget
12329	 * Note: PASD motherboards uses the Line In 2 as the input for front
12330	 * panel mic (mic 2)
12331	 */
12332	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12333	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12334	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12335	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12336	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12337	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12338	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12339	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12340	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12341	/*
12342	 * Set up output mixers (0x0c - 0x0e)
12343	 */
12344	/* set vol=0 to output mixers */
12345	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12346	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12347	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12348
12349	/* set up input amps for analog loopback */
12350	/* Amp Indices: DAC = 0, mixer = 1 */
12351	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12352	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12353	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12354	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12355	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12356	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12357
12358
12359	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
12360	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
12361	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
12362	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
12363	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
12364	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
12365	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
12366
12367	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12368	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12369
12370	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12371	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12372
12373	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12374	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12375	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12376	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12377	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12378	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12379
12380	/* FIXME: use matrix-type input source selection */
12381	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12382	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12383	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12384	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12385	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12386	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12387	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12388        /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12389	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12390	/* Input mixer2 */
12391	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12392	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12393	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12394	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12395	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12396        /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12397	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12398	/* Input mixer3 */
12399	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12400	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12401	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12402	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12403	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12404        /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12405	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12406
12407	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12408
12409	{ }
12410};
12411
12412static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12413
12414	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
12415	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12416	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12417
12418	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
12419	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
12420	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12421	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12422
12423	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
12424	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12425	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12426	{}
12427};
12428
12429/*
12430 * Pin config fixes
12431 */
12432enum {
12433	PINFIX_FSC_H270,
12434};
12435
12436static const struct alc_fixup alc262_fixups[] = {
12437	[PINFIX_FSC_H270] = {
12438		.pins = (const struct alc_pincfg[]) {
12439			{ 0x14, 0x99130110 }, /* speaker */
12440			{ 0x15, 0x0221142f }, /* front HP */
12441			{ 0x1b, 0x0121141f }, /* rear HP */
12442			{ }
12443		}
12444	},
12445	[PINFIX_PB_M5210] = {
12446		.verbs = (const struct hda_verb[]) {
12447			{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
12448			{}
12449		}
12450	},
12451};
12452
12453static struct snd_pci_quirk alc262_fixup_tbl[] = {
12454	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12455	{}
12456};
12457
12458
12459#ifdef CONFIG_SND_HDA_POWER_SAVE
12460#define alc262_loopbacks	alc880_loopbacks
12461#endif
12462
12463/* pcm configuration: identical with ALC880 */
12464#define alc262_pcm_analog_playback	alc880_pcm_analog_playback
12465#define alc262_pcm_analog_capture	alc880_pcm_analog_capture
12466#define alc262_pcm_digital_playback	alc880_pcm_digital_playback
12467#define alc262_pcm_digital_capture	alc880_pcm_digital_capture
12468
12469/*
12470 * BIOS auto configuration
12471 */
12472static int alc262_parse_auto_config(struct hda_codec *codec)
12473{
12474	struct alc_spec *spec = codec->spec;
12475	int err;
12476	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12477
12478	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12479					   alc262_ignore);
12480	if (err < 0)
12481		return err;
12482	if (!spec->autocfg.line_outs) {
12483		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12484			spec->multiout.max_channels = 2;
12485			spec->no_analog = 1;
12486			goto dig_only;
12487		}
12488		return 0; /* can't find valid BIOS pin config */
12489	}
12490	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12491	if (err < 0)
12492		return err;
12493	err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12494	if (err < 0)
12495		return err;
12496
12497	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12498
12499 dig_only:
12500	alc_auto_parse_digital(codec);
12501
12502	if (spec->kctls.list)
12503		add_mixer(spec, spec->kctls.list);
12504
12505	add_verb(spec, alc262_volume_init_verbs);
12506	spec->num_mux_defs = 1;
12507	spec->input_mux = &spec->private_imux[0];
12508
12509	err = alc_auto_add_mic_boost(codec);
12510	if (err < 0)
12511		return err;
12512
12513	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12514
12515	return 1;
12516}
12517
12518#define alc262_auto_init_multi_out	alc882_auto_init_multi_out
12519#define alc262_auto_init_hp_out		alc882_auto_init_hp_out
12520#define alc262_auto_init_analog_input	alc882_auto_init_analog_input
12521#define alc262_auto_init_input_src	alc882_auto_init_input_src
12522
12523
12524/* init callback for auto-configuration model -- overriding the default init */
12525static void alc262_auto_init(struct hda_codec *codec)
12526{
12527	struct alc_spec *spec = codec->spec;
12528	alc262_auto_init_multi_out(codec);
12529	alc262_auto_init_hp_out(codec);
12530	alc262_auto_init_analog_input(codec);
12531	alc262_auto_init_input_src(codec);
12532	alc_auto_init_digital(codec);
12533	if (spec->unsol_event)
12534		alc_inithook(codec);
12535}
12536
12537/*
12538 * configuration and preset
12539 */
12540static const char *alc262_models[ALC262_MODEL_LAST] = {
12541	[ALC262_BASIC]		= "basic",
12542	[ALC262_HIPPO]		= "hippo",
12543	[ALC262_HIPPO_1]	= "hippo_1",
12544	[ALC262_FUJITSU]	= "fujitsu",
12545	[ALC262_HP_BPC]		= "hp-bpc",
12546	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12547	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
12548	[ALC262_HP_RP5700]	= "hp-rp5700",
12549	[ALC262_BENQ_ED8]	= "benq",
12550	[ALC262_BENQ_T31]	= "benq-t31",
12551	[ALC262_SONY_ASSAMD]	= "sony-assamd",
12552	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
12553	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
12554	[ALC262_ULTRA]		= "ultra",
12555	[ALC262_LENOVO_3000]	= "lenovo-3000",
12556	[ALC262_NEC]		= "nec",
12557	[ALC262_TYAN]		= "tyan",
12558	[ALC262_AUTO]		= "auto",
12559};
12560
12561static struct snd_pci_quirk alc262_cfg_tbl[] = {
12562	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12563	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12564	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12565			   ALC262_HP_BPC),
12566	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12567			   ALC262_HP_BPC),
12568	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12569			   ALC262_HP_BPC),
12570	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12571	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12572	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12573	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12574	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12575	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12576	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12577	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12578	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12579	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12580	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12581	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12582		      ALC262_HP_TC_T5735),
12583	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12584	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12585	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12586	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12587	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12588	SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12589	SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12590	SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12591#if 0 /* disable the quirk since model=auto works better in recent versions */
12592	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12593			   ALC262_SONY_ASSAMD),
12594#endif
12595	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12596		      ALC262_TOSHIBA_RX1),
12597	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12598	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12599	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12600	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12601	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12602			   ALC262_ULTRA),
12603	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12604	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12605	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12606	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12607	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12608	{}
12609};
12610
12611static struct alc_config_preset alc262_presets[] = {
12612	[ALC262_BASIC] = {
12613		.mixers = { alc262_base_mixer },
12614		.init_verbs = { alc262_init_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	},
12622	[ALC262_HIPPO] = {
12623		.mixers = { alc262_hippo_mixer },
12624		.init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12625		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12626		.dac_nids = alc262_dac_nids,
12627		.hp_nid = 0x03,
12628		.dig_out_nid = ALC262_DIGOUT_NID,
12629		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12630		.channel_mode = alc262_modes,
12631		.input_mux = &alc262_capture_source,
12632		.unsol_event = alc262_hippo_unsol_event,
12633		.setup = alc262_hippo_setup,
12634		.init_hook = alc262_hippo_automute,
12635	},
12636	[ALC262_HIPPO_1] = {
12637		.mixers = { alc262_hippo1_mixer },
12638		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12639		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12640		.dac_nids = alc262_dac_nids,
12641		.hp_nid = 0x02,
12642		.dig_out_nid = ALC262_DIGOUT_NID,
12643		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12644		.channel_mode = alc262_modes,
12645		.input_mux = &alc262_capture_source,
12646		.unsol_event = alc262_hippo_unsol_event,
12647		.setup = alc262_hippo1_setup,
12648		.init_hook = alc262_hippo_automute,
12649	},
12650	[ALC262_FUJITSU] = {
12651		.mixers = { alc262_fujitsu_mixer },
12652		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12653				alc262_fujitsu_unsol_verbs },
12654		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12655		.dac_nids = alc262_dac_nids,
12656		.hp_nid = 0x03,
12657		.dig_out_nid = ALC262_DIGOUT_NID,
12658		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12659		.channel_mode = alc262_modes,
12660		.input_mux = &alc262_fujitsu_capture_source,
12661		.unsol_event = alc262_fujitsu_unsol_event,
12662		.init_hook = alc262_fujitsu_init_hook,
12663	},
12664	[ALC262_HP_BPC] = {
12665		.mixers = { alc262_HP_BPC_mixer },
12666		.init_verbs = { alc262_HP_BPC_init_verbs },
12667		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12668		.dac_nids = alc262_dac_nids,
12669		.hp_nid = 0x03,
12670		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12671		.channel_mode = alc262_modes,
12672		.input_mux = &alc262_HP_capture_source,
12673		.unsol_event = alc262_hp_bpc_unsol_event,
12674		.init_hook = alc262_hp_bpc_automute,
12675	},
12676	[ALC262_HP_BPC_D7000_WF] = {
12677		.mixers = { alc262_HP_BPC_WildWest_mixer },
12678		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12679		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12680		.dac_nids = alc262_dac_nids,
12681		.hp_nid = 0x03,
12682		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12683		.channel_mode = alc262_modes,
12684		.input_mux = &alc262_HP_D7000_capture_source,
12685		.unsol_event = alc262_hp_wildwest_unsol_event,
12686		.init_hook = alc262_hp_wildwest_automute,
12687	},
12688	[ALC262_HP_BPC_D7000_WL] = {
12689		.mixers = { alc262_HP_BPC_WildWest_mixer,
12690			    alc262_HP_BPC_WildWest_option_mixer },
12691		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12692		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12693		.dac_nids = alc262_dac_nids,
12694		.hp_nid = 0x03,
12695		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12696		.channel_mode = alc262_modes,
12697		.input_mux = &alc262_HP_D7000_capture_source,
12698		.unsol_event = alc262_hp_wildwest_unsol_event,
12699		.init_hook = alc262_hp_wildwest_automute,
12700	},
12701	[ALC262_HP_TC_T5735] = {
12702		.mixers = { alc262_hp_t5735_mixer },
12703		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12704		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12705		.dac_nids = alc262_dac_nids,
12706		.hp_nid = 0x03,
12707		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12708		.channel_mode = alc262_modes,
12709		.input_mux = &alc262_capture_source,
12710		.unsol_event = alc_sku_unsol_event,
12711		.setup = alc262_hp_t5735_setup,
12712		.init_hook = alc_inithook,
12713	},
12714	[ALC262_HP_RP5700] = {
12715		.mixers = { alc262_hp_rp5700_mixer },
12716		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12717		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12718		.dac_nids = alc262_dac_nids,
12719		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12720		.channel_mode = alc262_modes,
12721		.input_mux = &alc262_hp_rp5700_capture_source,
12722        },
12723	[ALC262_BENQ_ED8] = {
12724		.mixers = { alc262_base_mixer },
12725		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12726		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12727		.dac_nids = alc262_dac_nids,
12728		.hp_nid = 0x03,
12729		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12730		.channel_mode = alc262_modes,
12731		.input_mux = &alc262_capture_source,
12732	},
12733	[ALC262_SONY_ASSAMD] = {
12734		.mixers = { alc262_sony_mixer },
12735		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12736		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12737		.dac_nids = alc262_dac_nids,
12738		.hp_nid = 0x02,
12739		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12740		.channel_mode = alc262_modes,
12741		.input_mux = &alc262_capture_source,
12742		.unsol_event = alc262_hippo_unsol_event,
12743		.setup = alc262_hippo_setup,
12744		.init_hook = alc262_hippo_automute,
12745	},
12746	[ALC262_BENQ_T31] = {
12747		.mixers = { alc262_benq_t31_mixer },
12748		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12749				alc_hp15_unsol_verbs },
12750		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12751		.dac_nids = alc262_dac_nids,
12752		.hp_nid = 0x03,
12753		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12754		.channel_mode = alc262_modes,
12755		.input_mux = &alc262_capture_source,
12756		.unsol_event = alc262_hippo_unsol_event,
12757		.setup = alc262_hippo_setup,
12758		.init_hook = alc262_hippo_automute,
12759	},
12760	[ALC262_ULTRA] = {
12761		.mixers = { alc262_ultra_mixer },
12762		.cap_mixer = alc262_ultra_capture_mixer,
12763		.init_verbs = { alc262_ultra_verbs },
12764		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12765		.dac_nids = alc262_dac_nids,
12766		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12767		.channel_mode = alc262_modes,
12768		.input_mux = &alc262_ultra_capture_source,
12769		.adc_nids = alc262_adc_nids, /* ADC0 */
12770		.capsrc_nids = alc262_capsrc_nids,
12771		.num_adc_nids = 1, /* single ADC */
12772		.unsol_event = alc262_ultra_unsol_event,
12773		.init_hook = alc262_ultra_automute,
12774	},
12775	[ALC262_LENOVO_3000] = {
12776		.mixers = { alc262_lenovo_3000_mixer },
12777		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12778				alc262_lenovo_3000_unsol_verbs,
12779				alc262_lenovo_3000_init_verbs },
12780		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12781		.dac_nids = alc262_dac_nids,
12782		.hp_nid = 0x03,
12783		.dig_out_nid = ALC262_DIGOUT_NID,
12784		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12785		.channel_mode = alc262_modes,
12786		.input_mux = &alc262_fujitsu_capture_source,
12787		.unsol_event = alc262_lenovo_3000_unsol_event,
12788	},
12789	[ALC262_NEC] = {
12790		.mixers = { alc262_nec_mixer },
12791		.init_verbs = { alc262_nec_verbs },
12792		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12793		.dac_nids = alc262_dac_nids,
12794		.hp_nid = 0x03,
12795		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12796		.channel_mode = alc262_modes,
12797		.input_mux = &alc262_capture_source,
12798	},
12799	[ALC262_TOSHIBA_S06] = {
12800		.mixers = { alc262_toshiba_s06_mixer },
12801		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12802							alc262_eapd_verbs },
12803		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12804		.capsrc_nids = alc262_dmic_capsrc_nids,
12805		.dac_nids = alc262_dac_nids,
12806		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12807		.num_adc_nids = 1, /* single ADC */
12808		.dig_out_nid = ALC262_DIGOUT_NID,
12809		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12810		.channel_mode = alc262_modes,
12811		.unsol_event = alc_sku_unsol_event,
12812		.setup = alc262_toshiba_s06_setup,
12813		.init_hook = alc_inithook,
12814	},
12815	[ALC262_TOSHIBA_RX1] = {
12816		.mixers = { alc262_toshiba_rx1_mixer },
12817		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12818		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12819		.dac_nids = alc262_dac_nids,
12820		.hp_nid = 0x03,
12821		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12822		.channel_mode = alc262_modes,
12823		.input_mux = &alc262_capture_source,
12824		.unsol_event = alc262_hippo_unsol_event,
12825		.setup = alc262_hippo_setup,
12826		.init_hook = alc262_hippo_automute,
12827	},
12828	[ALC262_TYAN] = {
12829		.mixers = { alc262_tyan_mixer },
12830		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12831		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12832		.dac_nids = alc262_dac_nids,
12833		.hp_nid = 0x02,
12834		.dig_out_nid = ALC262_DIGOUT_NID,
12835		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12836		.channel_mode = alc262_modes,
12837		.input_mux = &alc262_capture_source,
12838		.unsol_event = alc_automute_amp_unsol_event,
12839		.setup = alc262_tyan_setup,
12840		.init_hook = alc_automute_amp,
12841	},
12842};
12843
12844static int patch_alc262(struct hda_codec *codec)
12845{
12846	struct alc_spec *spec;
12847	int board_config;
12848	int err;
12849
12850	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12851	if (spec == NULL)
12852		return -ENOMEM;
12853
12854	codec->spec = spec;
12855#if 0
12856	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12857	 * under-run
12858	 */
12859	{
12860	int tmp;
12861	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12862	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12863	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12864	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12865	}
12866#endif
12867	alc_auto_parse_customize_define(codec);
12868
12869	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12870
12871	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12872						  alc262_models,
12873						  alc262_cfg_tbl);
12874
12875	if (board_config < 0) {
12876		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12877		       codec->chip_name);
12878		board_config = ALC262_AUTO;
12879	}
12880
12881	if (board_config == ALC262_AUTO)
12882		alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1);
12883
12884	if (board_config == ALC262_AUTO) {
12885		/* automatic parse from the BIOS config */
12886		err = alc262_parse_auto_config(codec);
12887		if (err < 0) {
12888			alc_free(codec);
12889			return err;
12890		} else if (!err) {
12891			printk(KERN_INFO
12892			       "hda_codec: Cannot set up configuration "
12893			       "from BIOS.  Using base mode...\n");
12894			board_config = ALC262_BASIC;
12895		}
12896	}
12897
12898	if (!spec->no_analog && has_cdefine_beep(codec)) {
12899		err = snd_hda_attach_beep_device(codec, 0x1);
12900		if (err < 0) {
12901			alc_free(codec);
12902			return err;
12903		}
12904	}
12905
12906	if (board_config != ALC262_AUTO)
12907		setup_preset(codec, &alc262_presets[board_config]);
12908
12909	spec->stream_analog_playback = &alc262_pcm_analog_playback;
12910	spec->stream_analog_capture = &alc262_pcm_analog_capture;
12911
12912	spec->stream_digital_playback = &alc262_pcm_digital_playback;
12913	spec->stream_digital_capture = &alc262_pcm_digital_capture;
12914
12915	if (!spec->adc_nids && spec->input_mux) {
12916		int i;
12917		/* check whether the digital-mic has to be supported */
12918		for (i = 0; i < spec->input_mux->num_items; i++) {
12919			if (spec->input_mux->items[i].index >= 9)
12920				break;
12921		}
12922		if (i < spec->input_mux->num_items) {
12923			/* use only ADC0 */
12924			spec->adc_nids = alc262_dmic_adc_nids;
12925			spec->num_adc_nids = 1;
12926			spec->capsrc_nids = alc262_dmic_capsrc_nids;
12927		} else {
12928			/* all analog inputs */
12929			/* check whether NID 0x07 is valid */
12930			unsigned int wcap = get_wcaps(codec, 0x07);
12931
12932			/* get type */
12933			wcap = get_wcaps_type(wcap);
12934			if (wcap != AC_WID_AUD_IN) {
12935				spec->adc_nids = alc262_adc_nids_alt;
12936				spec->num_adc_nids =
12937					ARRAY_SIZE(alc262_adc_nids_alt);
12938				spec->capsrc_nids = alc262_capsrc_nids_alt;
12939			} else {
12940				spec->adc_nids = alc262_adc_nids;
12941				spec->num_adc_nids =
12942					ARRAY_SIZE(alc262_adc_nids);
12943				spec->capsrc_nids = alc262_capsrc_nids;
12944			}
12945		}
12946	}
12947	if (!spec->cap_mixer && !spec->no_analog)
12948		set_capture_mixer(codec);
12949	if (!spec->no_analog && has_cdefine_beep(codec))
12950		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12951
12952	if (board_config == ALC262_AUTO)
12953		alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0);
12954
12955	spec->vmaster_nid = 0x0c;
12956
12957	codec->patch_ops = alc_patch_ops;
12958	if (board_config == ALC262_AUTO)
12959		spec->init_hook = alc262_auto_init;
12960
12961	alc_init_jacks(codec);
12962#ifdef CONFIG_SND_HDA_POWER_SAVE
12963	if (!spec->loopback.amplist)
12964		spec->loopback.amplist = alc262_loopbacks;
12965#endif
12966
12967	return 0;
12968}
12969
12970/*
12971 *  ALC268 channel source setting (2 channel)
12972 */
12973#define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
12974#define alc268_modes		alc260_modes
12975
12976static hda_nid_t alc268_dac_nids[2] = {
12977	/* front, hp */
12978	0x02, 0x03
12979};
12980
12981static hda_nid_t alc268_adc_nids[2] = {
12982	/* ADC0-1 */
12983	0x08, 0x07
12984};
12985
12986static hda_nid_t alc268_adc_nids_alt[1] = {
12987	/* ADC0 */
12988	0x08
12989};
12990
12991static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12992
12993static struct snd_kcontrol_new alc268_base_mixer[] = {
12994	/* output mixer control */
12995	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12996	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12997	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12998	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12999	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13000	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13001	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13002	{ }
13003};
13004
13005static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13006	/* output mixer control */
13007	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13008	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13009	ALC262_HIPPO_MASTER_SWITCH,
13010	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13011	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13012	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13013	{ }
13014};
13015
13016/* bind Beep switches of both NID 0x0f and 0x10 */
13017static struct hda_bind_ctls alc268_bind_beep_sw = {
13018	.ops = &snd_hda_bind_sw,
13019	.values = {
13020		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13021		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13022		0
13023	},
13024};
13025
13026static struct snd_kcontrol_new alc268_beep_mixer[] = {
13027	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13028	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13029	{ }
13030};
13031
13032static struct hda_verb alc268_eapd_verbs[] = {
13033	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13034	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13035	{ }
13036};
13037
13038/* Toshiba specific */
13039static struct hda_verb alc268_toshiba_verbs[] = {
13040	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13041	{ } /* end */
13042};
13043
13044/* Acer specific */
13045/* bind volumes of both NID 0x02 and 0x03 */
13046static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13047	.ops = &snd_hda_bind_vol,
13048	.values = {
13049		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13050		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13051		0
13052	},
13053};
13054
13055/* mute/unmute internal speaker according to the hp jack and mute state */
13056static void alc268_acer_automute(struct hda_codec *codec, int force)
13057{
13058	struct alc_spec *spec = codec->spec;
13059	unsigned int mute;
13060
13061	if (force || !spec->sense_updated) {
13062		spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13063		spec->sense_updated = 1;
13064	}
13065	if (spec->jack_present)
13066		mute = HDA_AMP_MUTE; /* mute internal speaker */
13067	else /* unmute internal speaker if necessary */
13068		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13069	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13070				 HDA_AMP_MUTE, mute);
13071}
13072
13073
13074/* bind hp and internal speaker mute (with plug check) */
13075static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13076				     struct snd_ctl_elem_value *ucontrol)
13077{
13078	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13079	long *valp = ucontrol->value.integer.value;
13080	int change;
13081
13082	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13083	if (change)
13084		alc268_acer_automute(codec, 0);
13085	return change;
13086}
13087
13088static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13089	/* output mixer control */
13090	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13091	{
13092		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13093		.name = "Master Playback Switch",
13094		.subdevice = HDA_SUBDEV_AMP_FLAG,
13095		.info = snd_hda_mixer_amp_switch_info,
13096		.get = snd_hda_mixer_amp_switch_get,
13097		.put = alc268_acer_master_sw_put,
13098		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13099	},
13100	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13101	{ }
13102};
13103
13104static struct snd_kcontrol_new alc268_acer_mixer[] = {
13105	/* output mixer control */
13106	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13107	{
13108		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13109		.name = "Master Playback Switch",
13110		.subdevice = HDA_SUBDEV_AMP_FLAG,
13111		.info = snd_hda_mixer_amp_switch_info,
13112		.get = snd_hda_mixer_amp_switch_get,
13113		.put = alc268_acer_master_sw_put,
13114		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13115	},
13116	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13117	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13118	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13119	{ }
13120};
13121
13122static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13123	/* output mixer control */
13124	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13125	{
13126		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13127		.name = "Master Playback Switch",
13128		.subdevice = HDA_SUBDEV_AMP_FLAG,
13129		.info = snd_hda_mixer_amp_switch_info,
13130		.get = snd_hda_mixer_amp_switch_get,
13131		.put = alc268_acer_master_sw_put,
13132		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13133	},
13134	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13135	HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
13136	{ }
13137};
13138
13139static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13140	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13141	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13142	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13143	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13144	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13145	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13146	{ }
13147};
13148
13149static struct hda_verb alc268_acer_verbs[] = {
13150	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13151	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13152	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13153	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13154	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13155	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13156	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13157	{ }
13158};
13159
13160/* unsolicited event for HP jack sensing */
13161#define alc268_toshiba_unsol_event	alc262_hippo_unsol_event
13162#define alc268_toshiba_setup		alc262_hippo_setup
13163#define alc268_toshiba_automute		alc262_hippo_automute
13164
13165static void alc268_acer_unsol_event(struct hda_codec *codec,
13166				       unsigned int res)
13167{
13168	if ((res >> 26) != ALC880_HP_EVENT)
13169		return;
13170	alc268_acer_automute(codec, 1);
13171}
13172
13173static void alc268_acer_init_hook(struct hda_codec *codec)
13174{
13175	alc268_acer_automute(codec, 1);
13176}
13177
13178/* toggle speaker-output according to the hp-jack state */
13179static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13180{
13181	unsigned int present;
13182	unsigned char bits;
13183
13184	present = snd_hda_jack_detect(codec, 0x15);
13185	bits = present ? HDA_AMP_MUTE : 0;
13186	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13187				 HDA_AMP_MUTE, bits);
13188	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13189				 HDA_AMP_MUTE, bits);
13190}
13191
13192static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13193				    unsigned int res)
13194{
13195	switch (res >> 26) {
13196	case ALC880_HP_EVENT:
13197		alc268_aspire_one_speaker_automute(codec);
13198		break;
13199	case ALC880_MIC_EVENT:
13200		alc_mic_automute(codec);
13201		break;
13202	}
13203}
13204
13205static void alc268_acer_lc_setup(struct hda_codec *codec)
13206{
13207	struct alc_spec *spec = codec->spec;
13208	spec->ext_mic.pin = 0x18;
13209	spec->ext_mic.mux_idx = 0;
13210	spec->int_mic.pin = 0x12;
13211	spec->int_mic.mux_idx = 6;
13212	spec->auto_mic = 1;
13213}
13214
13215static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13216{
13217	alc268_aspire_one_speaker_automute(codec);
13218	alc_mic_automute(codec);
13219}
13220
13221static struct snd_kcontrol_new alc268_dell_mixer[] = {
13222	/* output mixer control */
13223	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13224	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13225	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13226	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13227	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13228	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13229	{ }
13230};
13231
13232static struct hda_verb alc268_dell_verbs[] = {
13233	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13234	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13235	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13236	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13237	{ }
13238};
13239
13240/* mute/unmute internal speaker according to the hp jack and mute state */
13241static void alc268_dell_setup(struct hda_codec *codec)
13242{
13243	struct alc_spec *spec = codec->spec;
13244
13245	spec->autocfg.hp_pins[0] = 0x15;
13246	spec->autocfg.speaker_pins[0] = 0x14;
13247	spec->ext_mic.pin = 0x18;
13248	spec->ext_mic.mux_idx = 0;
13249	spec->int_mic.pin = 0x19;
13250	spec->int_mic.mux_idx = 1;
13251	spec->auto_mic = 1;
13252}
13253
13254static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13255	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13256	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13257	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13258	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13259	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13260	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13261	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13262	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13263	{ }
13264};
13265
13266static struct hda_verb alc267_quanta_il1_verbs[] = {
13267	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13268	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13269	{ }
13270};
13271
13272static void alc267_quanta_il1_setup(struct hda_codec *codec)
13273{
13274	struct alc_spec *spec = codec->spec;
13275	spec->autocfg.hp_pins[0] = 0x15;
13276	spec->autocfg.speaker_pins[0] = 0x14;
13277	spec->ext_mic.pin = 0x18;
13278	spec->ext_mic.mux_idx = 0;
13279	spec->int_mic.pin = 0x19;
13280	spec->int_mic.mux_idx = 1;
13281	spec->auto_mic = 1;
13282}
13283
13284/*
13285 * generic initialization of ADC, input mixers and output mixers
13286 */
13287static struct hda_verb alc268_base_init_verbs[] = {
13288	/* Unmute DAC0-1 and set vol = 0 */
13289	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13290	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13291
13292	/*
13293	 * Set up output mixers (0x0c - 0x0e)
13294	 */
13295	/* set vol=0 to output mixers */
13296	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13297        {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13298
13299	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13300	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13301
13302	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13303	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13304	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13305	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13306	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13307	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13308	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13309	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13310
13311	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13312	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13313	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13314	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13315	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13316
13317	/* set PCBEEP vol = 0, mute connections */
13318	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13319	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13320	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13321
13322	/* Unmute Selector 23h,24h and set the default input to mic-in */
13323
13324	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13325	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13326	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13327	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13328
13329	{ }
13330};
13331
13332/*
13333 * generic initialization of ADC, input mixers and output mixers
13334 */
13335static struct hda_verb alc268_volume_init_verbs[] = {
13336	/* set output DAC */
13337	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13338	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13339
13340	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13341	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13342	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13343	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13344	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13345
13346	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13347	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13348	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13349
13350	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13351	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13352
13353	/* set PCBEEP vol = 0, mute connections */
13354	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13355	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13356	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13357
13358	{ }
13359};
13360
13361static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13362	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13363	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13364	{ } /* end */
13365};
13366
13367static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13368	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13369	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13370	_DEFINE_CAPSRC(1),
13371	{ } /* end */
13372};
13373
13374static struct snd_kcontrol_new alc268_capture_mixer[] = {
13375	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13376	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13377	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13378	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13379	_DEFINE_CAPSRC(2),
13380	{ } /* end */
13381};
13382
13383static struct hda_input_mux alc268_capture_source = {
13384	.num_items = 4,
13385	.items = {
13386		{ "Mic", 0x0 },
13387		{ "Front Mic", 0x1 },
13388		{ "Line", 0x2 },
13389		{ "CD", 0x3 },
13390	},
13391};
13392
13393static struct hda_input_mux alc268_acer_capture_source = {
13394	.num_items = 3,
13395	.items = {
13396		{ "Mic", 0x0 },
13397		{ "Internal Mic", 0x1 },
13398		{ "Line", 0x2 },
13399	},
13400};
13401
13402static struct hda_input_mux alc268_acer_dmic_capture_source = {
13403	.num_items = 3,
13404	.items = {
13405		{ "Mic", 0x0 },
13406		{ "Internal Mic", 0x6 },
13407		{ "Line", 0x2 },
13408	},
13409};
13410
13411#ifdef CONFIG_SND_DEBUG
13412static struct snd_kcontrol_new alc268_test_mixer[] = {
13413	/* Volume widgets */
13414	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13415	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13416	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13417	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13418	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13419	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13420	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13421	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13422	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13423	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13424	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13425	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13426	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13427	/* The below appears problematic on some hardwares */
13428	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13429	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13430	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13431	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13432	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13433
13434	/* Modes for retasking pin widgets */
13435	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13436	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13437	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13438	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13439
13440	/* Controls for GPIO pins, assuming they are configured as outputs */
13441	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13442	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13443	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13444	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13445
13446	/* Switches to allow the digital SPDIF output pin to be enabled.
13447	 * The ALC268 does not have an SPDIF input.
13448	 */
13449	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13450
13451	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
13452	 * this output to turn on an external amplifier.
13453	 */
13454	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13455	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13456
13457	{ } /* end */
13458};
13459#endif
13460
13461/* create input playback/capture controls for the given pin */
13462static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13463				    const char *ctlname, int idx)
13464{
13465	hda_nid_t dac;
13466	int err;
13467
13468	switch (nid) {
13469	case 0x14:
13470	case 0x16:
13471		dac = 0x02;
13472		break;
13473	case 0x15:
13474	case 0x1a: /* ALC259/269 only */
13475	case 0x1b: /* ALC259/269 only */
13476	case 0x21: /* ALC269vb has this pin, too */
13477		dac = 0x03;
13478		break;
13479	default:
13480		snd_printd(KERN_WARNING "hda_codec: "
13481			   "ignoring pin 0x%x as unknown\n", nid);
13482		return 0;
13483	}
13484	if (spec->multiout.dac_nids[0] != dac &&
13485	    spec->multiout.dac_nids[1] != dac) {
13486		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13487				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13488						      HDA_OUTPUT));
13489		if (err < 0)
13490			return err;
13491		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13492	}
13493
13494	if (nid != 0x16)
13495		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13496			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13497	else /* mono */
13498		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13499			  HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13500	if (err < 0)
13501		return err;
13502	return 0;
13503}
13504
13505/* add playback controls from the parsed DAC table */
13506static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13507					     const struct auto_pin_cfg *cfg)
13508{
13509	hda_nid_t nid;
13510	int err;
13511
13512	spec->multiout.dac_nids = spec->private_dac_nids;
13513
13514	nid = cfg->line_out_pins[0];
13515	if (nid) {
13516		const char *name;
13517		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13518			name = "Speaker";
13519		else
13520			name = "Front";
13521		err = alc268_new_analog_output(spec, nid, name, 0);
13522		if (err < 0)
13523			return err;
13524	}
13525
13526	nid = cfg->speaker_pins[0];
13527	if (nid == 0x1d) {
13528		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13529				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13530		if (err < 0)
13531			return err;
13532	} else if (nid) {
13533		err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13534		if (err < 0)
13535			return err;
13536	}
13537	nid = cfg->hp_pins[0];
13538	if (nid) {
13539		err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13540		if (err < 0)
13541			return err;
13542	}
13543
13544	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13545	if (nid == 0x16) {
13546		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13547				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13548		if (err < 0)
13549			return err;
13550	}
13551	return 0;
13552}
13553
13554/* create playback/capture controls for input pins */
13555static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13556						const struct auto_pin_cfg *cfg)
13557{
13558	return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13559}
13560
13561static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13562					      hda_nid_t nid, int pin_type)
13563{
13564	int idx;
13565
13566	alc_set_pin_output(codec, nid, pin_type);
13567	if (nid == 0x14 || nid == 0x16)
13568		idx = 0;
13569	else
13570		idx = 1;
13571	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13572}
13573
13574static void alc268_auto_init_multi_out(struct hda_codec *codec)
13575{
13576	struct alc_spec *spec = codec->spec;
13577	int i;
13578
13579	for (i = 0; i < spec->autocfg.line_outs; i++) {
13580		hda_nid_t nid = spec->autocfg.line_out_pins[i];
13581		int pin_type = get_pin_type(spec->autocfg.line_out_type);
13582		alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13583	}
13584}
13585
13586static void alc268_auto_init_hp_out(struct hda_codec *codec)
13587{
13588	struct alc_spec *spec = codec->spec;
13589	hda_nid_t pin;
13590	int i;
13591
13592	for (i = 0; i < spec->autocfg.hp_outs; i++) {
13593		pin = spec->autocfg.hp_pins[i];
13594		alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13595	}
13596	for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13597		pin = spec->autocfg.speaker_pins[i];
13598		alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13599	}
13600	if (spec->autocfg.mono_out_pin)
13601		snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13602				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13603}
13604
13605static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13606{
13607	struct alc_spec *spec = codec->spec;
13608	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13609	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13610	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13611	unsigned int	dac_vol1, dac_vol2;
13612
13613	if (line_nid == 0x1d || speaker_nid == 0x1d) {
13614		snd_hda_codec_write(codec, speaker_nid, 0,
13615				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13616		/* mute mixer inputs from 0x1d */
13617		snd_hda_codec_write(codec, 0x0f, 0,
13618				    AC_VERB_SET_AMP_GAIN_MUTE,
13619				    AMP_IN_UNMUTE(1));
13620		snd_hda_codec_write(codec, 0x10, 0,
13621				    AC_VERB_SET_AMP_GAIN_MUTE,
13622				    AMP_IN_UNMUTE(1));
13623	} else {
13624		/* unmute mixer inputs from 0x1d */
13625		snd_hda_codec_write(codec, 0x0f, 0,
13626				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13627		snd_hda_codec_write(codec, 0x10, 0,
13628				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13629	}
13630
13631	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
13632	if (line_nid == 0x14)
13633		dac_vol2 = AMP_OUT_ZERO;
13634	else if (line_nid == 0x15)
13635		dac_vol1 = AMP_OUT_ZERO;
13636	if (hp_nid == 0x14)
13637		dac_vol2 = AMP_OUT_ZERO;
13638	else if (hp_nid == 0x15)
13639		dac_vol1 = AMP_OUT_ZERO;
13640	if (line_nid != 0x16 || hp_nid != 0x16 ||
13641	    spec->autocfg.line_out_pins[1] != 0x16 ||
13642	    spec->autocfg.line_out_pins[2] != 0x16)
13643		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13644
13645	snd_hda_codec_write(codec, 0x02, 0,
13646			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13647	snd_hda_codec_write(codec, 0x03, 0,
13648			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13649}
13650
13651/* pcm configuration: identical with ALC880 */
13652#define alc268_pcm_analog_playback	alc880_pcm_analog_playback
13653#define alc268_pcm_analog_capture	alc880_pcm_analog_capture
13654#define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
13655#define alc268_pcm_digital_playback	alc880_pcm_digital_playback
13656
13657/*
13658 * BIOS auto configuration
13659 */
13660static int alc268_parse_auto_config(struct hda_codec *codec)
13661{
13662	struct alc_spec *spec = codec->spec;
13663	int err;
13664	static hda_nid_t alc268_ignore[] = { 0 };
13665
13666	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13667					   alc268_ignore);
13668	if (err < 0)
13669		return err;
13670	if (!spec->autocfg.line_outs) {
13671		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13672			spec->multiout.max_channels = 2;
13673			spec->no_analog = 1;
13674			goto dig_only;
13675		}
13676		return 0; /* can't find valid BIOS pin config */
13677	}
13678	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13679	if (err < 0)
13680		return err;
13681	err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13682	if (err < 0)
13683		return err;
13684
13685	spec->multiout.max_channels = 2;
13686
13687 dig_only:
13688	/* digital only support output */
13689	alc_auto_parse_digital(codec);
13690	if (spec->kctls.list)
13691		add_mixer(spec, spec->kctls.list);
13692
13693	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13694		add_mixer(spec, alc268_beep_mixer);
13695
13696	add_verb(spec, alc268_volume_init_verbs);
13697	spec->num_mux_defs = 2;
13698	spec->input_mux = &spec->private_imux[0];
13699
13700	err = alc_auto_add_mic_boost(codec);
13701	if (err < 0)
13702		return err;
13703
13704	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13705
13706	return 1;
13707}
13708
13709#define alc268_auto_init_analog_input	alc882_auto_init_analog_input
13710
13711/* init callback for auto-configuration model -- overriding the default init */
13712static void alc268_auto_init(struct hda_codec *codec)
13713{
13714	struct alc_spec *spec = codec->spec;
13715	alc268_auto_init_multi_out(codec);
13716	alc268_auto_init_hp_out(codec);
13717	alc268_auto_init_mono_speaker_out(codec);
13718	alc268_auto_init_analog_input(codec);
13719	alc_auto_init_digital(codec);
13720	if (spec->unsol_event)
13721		alc_inithook(codec);
13722}
13723
13724/*
13725 * configuration and preset
13726 */
13727static const char *alc268_models[ALC268_MODEL_LAST] = {
13728	[ALC267_QUANTA_IL1]	= "quanta-il1",
13729	[ALC268_3ST]		= "3stack",
13730	[ALC268_TOSHIBA]	= "toshiba",
13731	[ALC268_ACER]		= "acer",
13732	[ALC268_ACER_DMIC]	= "acer-dmic",
13733	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
13734	[ALC268_DELL]		= "dell",
13735	[ALC268_ZEPTO]		= "zepto",
13736#ifdef CONFIG_SND_DEBUG
13737	[ALC268_TEST]		= "test",
13738#endif
13739	[ALC268_AUTO]		= "auto",
13740};
13741
13742static struct snd_pci_quirk alc268_cfg_tbl[] = {
13743	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13744	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13745	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13746	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13747	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13748	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13749						ALC268_ACER_ASPIRE_ONE),
13750	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13751	SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13752			"Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13753	/* almost compatible with toshiba but with optional digital outs;
13754	 * auto-probing seems working fine
13755	 */
13756	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13757			   ALC268_AUTO),
13758	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13759	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13760	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13761	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13762	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13763	{}
13764};
13765
13766/* Toshiba laptops have no unique PCI SSID but only codec SSID */
13767static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13768	SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13769	SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13770	SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13771			   ALC268_TOSHIBA),
13772	{}
13773};
13774
13775static struct alc_config_preset alc268_presets[] = {
13776	[ALC267_QUANTA_IL1] = {
13777		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13778			    alc268_capture_nosrc_mixer },
13779		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13780				alc267_quanta_il1_verbs },
13781		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13782		.dac_nids = alc268_dac_nids,
13783		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13784		.adc_nids = alc268_adc_nids_alt,
13785		.hp_nid = 0x03,
13786		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13787		.channel_mode = alc268_modes,
13788		.unsol_event = alc_sku_unsol_event,
13789		.setup = alc267_quanta_il1_setup,
13790		.init_hook = alc_inithook,
13791	},
13792	[ALC268_3ST] = {
13793		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13794			    alc268_beep_mixer },
13795		.init_verbs = { alc268_base_init_verbs },
13796		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13797		.dac_nids = alc268_dac_nids,
13798                .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13799                .adc_nids = alc268_adc_nids_alt,
13800		.capsrc_nids = alc268_capsrc_nids,
13801		.hp_nid = 0x03,
13802		.dig_out_nid = ALC268_DIGOUT_NID,
13803		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13804		.channel_mode = alc268_modes,
13805		.input_mux = &alc268_capture_source,
13806	},
13807	[ALC268_TOSHIBA] = {
13808		.mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13809			    alc268_beep_mixer },
13810		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13811				alc268_toshiba_verbs },
13812		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13813		.dac_nids = alc268_dac_nids,
13814		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13815		.adc_nids = alc268_adc_nids_alt,
13816		.capsrc_nids = alc268_capsrc_nids,
13817		.hp_nid = 0x03,
13818		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13819		.channel_mode = alc268_modes,
13820		.input_mux = &alc268_capture_source,
13821		.unsol_event = alc268_toshiba_unsol_event,
13822		.setup = alc268_toshiba_setup,
13823		.init_hook = alc268_toshiba_automute,
13824	},
13825	[ALC268_ACER] = {
13826		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13827			    alc268_beep_mixer },
13828		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13829				alc268_acer_verbs },
13830		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13831		.dac_nids = alc268_dac_nids,
13832		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13833		.adc_nids = alc268_adc_nids_alt,
13834		.capsrc_nids = alc268_capsrc_nids,
13835		.hp_nid = 0x02,
13836		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13837		.channel_mode = alc268_modes,
13838		.input_mux = &alc268_acer_capture_source,
13839		.unsol_event = alc268_acer_unsol_event,
13840		.init_hook = alc268_acer_init_hook,
13841	},
13842	[ALC268_ACER_DMIC] = {
13843		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13844			    alc268_beep_mixer },
13845		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13846				alc268_acer_verbs },
13847		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13848		.dac_nids = alc268_dac_nids,
13849		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13850		.adc_nids = alc268_adc_nids_alt,
13851		.capsrc_nids = alc268_capsrc_nids,
13852		.hp_nid = 0x02,
13853		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13854		.channel_mode = alc268_modes,
13855		.input_mux = &alc268_acer_dmic_capture_source,
13856		.unsol_event = alc268_acer_unsol_event,
13857		.init_hook = alc268_acer_init_hook,
13858	},
13859	[ALC268_ACER_ASPIRE_ONE] = {
13860		.mixers = { alc268_acer_aspire_one_mixer,
13861			    alc268_beep_mixer,
13862			    alc268_capture_nosrc_mixer },
13863		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13864				alc268_acer_aspire_one_verbs },
13865		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13866		.dac_nids = alc268_dac_nids,
13867		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13868		.adc_nids = alc268_adc_nids_alt,
13869		.capsrc_nids = alc268_capsrc_nids,
13870		.hp_nid = 0x03,
13871		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13872		.channel_mode = alc268_modes,
13873		.unsol_event = alc268_acer_lc_unsol_event,
13874		.setup = alc268_acer_lc_setup,
13875		.init_hook = alc268_acer_lc_init_hook,
13876	},
13877	[ALC268_DELL] = {
13878		.mixers = { alc268_dell_mixer, alc268_beep_mixer,
13879			    alc268_capture_nosrc_mixer },
13880		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13881				alc268_dell_verbs },
13882		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13883		.dac_nids = alc268_dac_nids,
13884		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13885		.adc_nids = alc268_adc_nids_alt,
13886		.capsrc_nids = alc268_capsrc_nids,
13887		.hp_nid = 0x02,
13888		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13889		.channel_mode = alc268_modes,
13890		.unsol_event = alc_sku_unsol_event,
13891		.setup = alc268_dell_setup,
13892		.init_hook = alc_inithook,
13893	},
13894	[ALC268_ZEPTO] = {
13895		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13896			    alc268_beep_mixer },
13897		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13898				alc268_toshiba_verbs },
13899		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13900		.dac_nids = alc268_dac_nids,
13901		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13902		.adc_nids = alc268_adc_nids_alt,
13903		.capsrc_nids = alc268_capsrc_nids,
13904		.hp_nid = 0x03,
13905		.dig_out_nid = ALC268_DIGOUT_NID,
13906		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13907		.channel_mode = alc268_modes,
13908		.input_mux = &alc268_capture_source,
13909		.setup = alc268_toshiba_setup,
13910		.init_hook = alc268_toshiba_automute,
13911	},
13912#ifdef CONFIG_SND_DEBUG
13913	[ALC268_TEST] = {
13914		.mixers = { alc268_test_mixer, alc268_capture_mixer },
13915		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13916				alc268_volume_init_verbs },
13917		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13918		.dac_nids = alc268_dac_nids,
13919		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13920		.adc_nids = alc268_adc_nids_alt,
13921		.capsrc_nids = alc268_capsrc_nids,
13922		.hp_nid = 0x03,
13923		.dig_out_nid = ALC268_DIGOUT_NID,
13924		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13925		.channel_mode = alc268_modes,
13926		.input_mux = &alc268_capture_source,
13927	},
13928#endif
13929};
13930
13931static int patch_alc268(struct hda_codec *codec)
13932{
13933	struct alc_spec *spec;
13934	int board_config;
13935	int i, has_beep, err;
13936
13937	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13938	if (spec == NULL)
13939		return -ENOMEM;
13940
13941	codec->spec = spec;
13942
13943	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13944						  alc268_models,
13945						  alc268_cfg_tbl);
13946
13947	if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13948		board_config = snd_hda_check_board_codec_sid_config(codec,
13949			ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13950
13951	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13952		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13953		       codec->chip_name);
13954		board_config = ALC268_AUTO;
13955	}
13956
13957	if (board_config == ALC268_AUTO) {
13958		/* automatic parse from the BIOS config */
13959		err = alc268_parse_auto_config(codec);
13960		if (err < 0) {
13961			alc_free(codec);
13962			return err;
13963		} else if (!err) {
13964			printk(KERN_INFO
13965			       "hda_codec: Cannot set up configuration "
13966			       "from BIOS.  Using base mode...\n");
13967			board_config = ALC268_3ST;
13968		}
13969	}
13970
13971	if (board_config != ALC268_AUTO)
13972		setup_preset(codec, &alc268_presets[board_config]);
13973
13974	spec->stream_analog_playback = &alc268_pcm_analog_playback;
13975	spec->stream_analog_capture = &alc268_pcm_analog_capture;
13976	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13977
13978	spec->stream_digital_playback = &alc268_pcm_digital_playback;
13979
13980	has_beep = 0;
13981	for (i = 0; i < spec->num_mixers; i++) {
13982		if (spec->mixers[i] == alc268_beep_mixer) {
13983			has_beep = 1;
13984			break;
13985		}
13986	}
13987
13988	if (has_beep) {
13989		err = snd_hda_attach_beep_device(codec, 0x1);
13990		if (err < 0) {
13991			alc_free(codec);
13992			return err;
13993		}
13994		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13995			/* override the amp caps for beep generator */
13996			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13997					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13998					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13999					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14000					  (0 << AC_AMPCAP_MUTE_SHIFT));
14001	}
14002
14003	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14004		/* check whether NID 0x07 is valid */
14005		unsigned int wcap = get_wcaps(codec, 0x07);
14006		int i;
14007
14008		spec->capsrc_nids = alc268_capsrc_nids;
14009		/* get type */
14010		wcap = get_wcaps_type(wcap);
14011		if (spec->auto_mic ||
14012		    wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14013			spec->adc_nids = alc268_adc_nids_alt;
14014			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14015			if (spec->auto_mic)
14016				fixup_automic_adc(codec);
14017			if (spec->auto_mic || spec->input_mux->num_items == 1)
14018				add_mixer(spec, alc268_capture_nosrc_mixer);
14019			else
14020				add_mixer(spec, alc268_capture_alt_mixer);
14021		} else {
14022			spec->adc_nids = alc268_adc_nids;
14023			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14024			add_mixer(spec, alc268_capture_mixer);
14025		}
14026		/* set default input source */
14027		for (i = 0; i < spec->num_adc_nids; i++)
14028			snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
14029				0, AC_VERB_SET_CONNECT_SEL,
14030				i < spec->num_mux_defs ?
14031				spec->input_mux[i].items[0].index :
14032				spec->input_mux->items[0].index);
14033	}
14034
14035	spec->vmaster_nid = 0x02;
14036
14037	codec->patch_ops = alc_patch_ops;
14038	if (board_config == ALC268_AUTO)
14039		spec->init_hook = alc268_auto_init;
14040
14041	alc_init_jacks(codec);
14042
14043	return 0;
14044}
14045
14046/*
14047 *  ALC269 channel source setting (2 channel)
14048 */
14049#define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
14050
14051#define alc269_dac_nids		alc260_dac_nids
14052
14053static hda_nid_t alc269_adc_nids[1] = {
14054	/* ADC1 */
14055	0x08,
14056};
14057
14058static hda_nid_t alc269_capsrc_nids[1] = {
14059	0x23,
14060};
14061
14062static hda_nid_t alc269vb_adc_nids[1] = {
14063	/* ADC1 */
14064	0x09,
14065};
14066
14067static hda_nid_t alc269vb_capsrc_nids[1] = {
14068	0x22,
14069};
14070
14071static hda_nid_t alc269_adc_candidates[] = {
14072	0x08, 0x09, 0x07,
14073};
14074
14075#define alc269_modes		alc260_modes
14076#define alc269_capture_source	alc880_lg_lw_capture_source
14077
14078static struct snd_kcontrol_new alc269_base_mixer[] = {
14079	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14080	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14081	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14082	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14083	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14084	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14085	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14086	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14087	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14088	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14089	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14090	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14091	{ } /* end */
14092};
14093
14094static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14095	/* output mixer control */
14096	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14097	{
14098		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14099		.name = "Master Playback Switch",
14100		.subdevice = HDA_SUBDEV_AMP_FLAG,
14101		.info = snd_hda_mixer_amp_switch_info,
14102		.get = snd_hda_mixer_amp_switch_get,
14103		.put = alc268_acer_master_sw_put,
14104		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14105	},
14106	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14107	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14108	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14109	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14110	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14111	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14112	{ }
14113};
14114
14115static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14116	/* output mixer control */
14117	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14118	{
14119		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14120		.name = "Master Playback Switch",
14121		.subdevice = HDA_SUBDEV_AMP_FLAG,
14122		.info = snd_hda_mixer_amp_switch_info,
14123		.get = snd_hda_mixer_amp_switch_get,
14124		.put = alc268_acer_master_sw_put,
14125		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14126	},
14127	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14128	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14129	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14130	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14131	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14132	HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
14133	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14134	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14135	HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
14136	{ }
14137};
14138
14139static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14140	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14141	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14142	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14143	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14144	{ } /* end */
14145};
14146
14147static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14148	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14149	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14150	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14151	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14152	{ } /* end */
14153};
14154
14155static struct snd_kcontrol_new alc269_asus_mixer[] = {
14156	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14157	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14158	{ } /* end */
14159};
14160
14161/* capture mixer elements */
14162static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14163	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14164	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14165	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14166	HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14167	{ } /* end */
14168};
14169
14170static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14171	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14172	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14173	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14174	{ } /* end */
14175};
14176
14177static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14178	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14179	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14180	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14181	HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
14182	{ } /* end */
14183};
14184
14185static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14186	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14187	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14188	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14189	{ } /* end */
14190};
14191
14192/* FSC amilo */
14193#define alc269_fujitsu_mixer	alc269_laptop_mixer
14194
14195static struct hda_verb alc269_quanta_fl1_verbs[] = {
14196	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14197	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14198	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14199	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14200	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14201	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14202	{ }
14203};
14204
14205static struct hda_verb alc269_lifebook_verbs[] = {
14206	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14207	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14208	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14209	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14210	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14211	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14212	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14213	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14214	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14215	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14216	{ }
14217};
14218
14219/* toggle speaker-output according to the hp-jack state */
14220static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14221{
14222	unsigned int present;
14223	unsigned char bits;
14224
14225	present = snd_hda_jack_detect(codec, 0x15);
14226	bits = present ? HDA_AMP_MUTE : 0;
14227	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14228				 HDA_AMP_MUTE, bits);
14229	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14230				 HDA_AMP_MUTE, bits);
14231
14232	snd_hda_codec_write(codec, 0x20, 0,
14233			AC_VERB_SET_COEF_INDEX, 0x0c);
14234	snd_hda_codec_write(codec, 0x20, 0,
14235			AC_VERB_SET_PROC_COEF, 0x680);
14236
14237	snd_hda_codec_write(codec, 0x20, 0,
14238			AC_VERB_SET_COEF_INDEX, 0x0c);
14239	snd_hda_codec_write(codec, 0x20, 0,
14240			AC_VERB_SET_PROC_COEF, 0x480);
14241}
14242
14243/* toggle speaker-output according to the hp-jacks state */
14244static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14245{
14246	unsigned int present;
14247	unsigned char bits;
14248
14249	/* Check laptop headphone socket */
14250	present = snd_hda_jack_detect(codec, 0x15);
14251
14252	/* Check port replicator headphone socket */
14253	present |= snd_hda_jack_detect(codec, 0x1a);
14254
14255	bits = present ? HDA_AMP_MUTE : 0;
14256	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14257				 HDA_AMP_MUTE, bits);
14258	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14259				 HDA_AMP_MUTE, bits);
14260
14261	snd_hda_codec_write(codec, 0x20, 0,
14262			AC_VERB_SET_COEF_INDEX, 0x0c);
14263	snd_hda_codec_write(codec, 0x20, 0,
14264			AC_VERB_SET_PROC_COEF, 0x680);
14265
14266	snd_hda_codec_write(codec, 0x20, 0,
14267			AC_VERB_SET_COEF_INDEX, 0x0c);
14268	snd_hda_codec_write(codec, 0x20, 0,
14269			AC_VERB_SET_PROC_COEF, 0x480);
14270}
14271
14272static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14273{
14274	unsigned int present_laptop;
14275	unsigned int present_dock;
14276
14277	present_laptop	= snd_hda_jack_detect(codec, 0x18);
14278	present_dock	= snd_hda_jack_detect(codec, 0x1b);
14279
14280	/* Laptop mic port overrides dock mic port, design decision */
14281	if (present_dock)
14282		snd_hda_codec_write(codec, 0x23, 0,
14283				AC_VERB_SET_CONNECT_SEL, 0x3);
14284	if (present_laptop)
14285		snd_hda_codec_write(codec, 0x23, 0,
14286				AC_VERB_SET_CONNECT_SEL, 0x0);
14287	if (!present_dock && !present_laptop)
14288		snd_hda_codec_write(codec, 0x23, 0,
14289				AC_VERB_SET_CONNECT_SEL, 0x1);
14290}
14291
14292static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14293				    unsigned int res)
14294{
14295	switch (res >> 26) {
14296	case ALC880_HP_EVENT:
14297		alc269_quanta_fl1_speaker_automute(codec);
14298		break;
14299	case ALC880_MIC_EVENT:
14300		alc_mic_automute(codec);
14301		break;
14302	}
14303}
14304
14305static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14306					unsigned int res)
14307{
14308	if ((res >> 26) == ALC880_HP_EVENT)
14309		alc269_lifebook_speaker_automute(codec);
14310	if ((res >> 26) == ALC880_MIC_EVENT)
14311		alc269_lifebook_mic_autoswitch(codec);
14312}
14313
14314static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14315{
14316	struct alc_spec *spec = codec->spec;
14317	spec->autocfg.hp_pins[0] = 0x15;
14318	spec->autocfg.speaker_pins[0] = 0x14;
14319	spec->ext_mic.pin = 0x18;
14320	spec->ext_mic.mux_idx = 0;
14321	spec->int_mic.pin = 0x19;
14322	spec->int_mic.mux_idx = 1;
14323	spec->auto_mic = 1;
14324}
14325
14326static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14327{
14328	alc269_quanta_fl1_speaker_automute(codec);
14329	alc_mic_automute(codec);
14330}
14331
14332static void alc269_lifebook_init_hook(struct hda_codec *codec)
14333{
14334	alc269_lifebook_speaker_automute(codec);
14335	alc269_lifebook_mic_autoswitch(codec);
14336}
14337
14338static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14339	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14340	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14341	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14342	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14343	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14344	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14345	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14346	{}
14347};
14348
14349static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14350	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14351	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14352	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14353	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14354	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14355	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14356	{}
14357};
14358
14359static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14360	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14361	{0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14362	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14363	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14364	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14365	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14366	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14367	{}
14368};
14369
14370static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14371	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14372	{0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14373	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14374	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14375	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14376	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14377	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14378	{}
14379};
14380
14381static struct hda_verb alc271_acer_dmic_verbs[] = {
14382	{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14383	{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14384	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14385	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14386	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14387	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14388	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14389	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14390	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14391	{0x22, AC_VERB_SET_CONNECT_SEL, 6},
14392	{ }
14393};
14394
14395/* toggle speaker-output according to the hp-jack state */
14396static void alc269_speaker_automute(struct hda_codec *codec)
14397{
14398	struct alc_spec *spec = codec->spec;
14399	unsigned int nid = spec->autocfg.hp_pins[0];
14400	unsigned int present;
14401	unsigned char bits;
14402
14403	present = snd_hda_jack_detect(codec, nid);
14404	bits = present ? HDA_AMP_MUTE : 0;
14405	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14406				 HDA_AMP_MUTE, bits);
14407	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14408				 HDA_AMP_MUTE, bits);
14409	alc_report_jack(codec, nid);
14410}
14411
14412/* unsolicited event for HP jack sensing */
14413static void alc269_laptop_unsol_event(struct hda_codec *codec,
14414				     unsigned int res)
14415{
14416	switch (res >> 26) {
14417	case ALC880_HP_EVENT:
14418		alc269_speaker_automute(codec);
14419		break;
14420	case ALC880_MIC_EVENT:
14421		alc_mic_automute(codec);
14422		break;
14423	}
14424}
14425
14426static void alc269_laptop_amic_setup(struct hda_codec *codec)
14427{
14428	struct alc_spec *spec = codec->spec;
14429	spec->autocfg.hp_pins[0] = 0x15;
14430	spec->autocfg.speaker_pins[0] = 0x14;
14431	spec->ext_mic.pin = 0x18;
14432	spec->ext_mic.mux_idx = 0;
14433	spec->int_mic.pin = 0x19;
14434	spec->int_mic.mux_idx = 1;
14435	spec->auto_mic = 1;
14436}
14437
14438static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14439{
14440	struct alc_spec *spec = codec->spec;
14441	spec->autocfg.hp_pins[0] = 0x15;
14442	spec->autocfg.speaker_pins[0] = 0x14;
14443	spec->ext_mic.pin = 0x18;
14444	spec->ext_mic.mux_idx = 0;
14445	spec->int_mic.pin = 0x12;
14446	spec->int_mic.mux_idx = 5;
14447	spec->auto_mic = 1;
14448}
14449
14450static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14451{
14452	struct alc_spec *spec = codec->spec;
14453	spec->autocfg.hp_pins[0] = 0x21;
14454	spec->autocfg.speaker_pins[0] = 0x14;
14455	spec->ext_mic.pin = 0x18;
14456	spec->ext_mic.mux_idx = 0;
14457	spec->int_mic.pin = 0x19;
14458	spec->int_mic.mux_idx = 1;
14459	spec->auto_mic = 1;
14460}
14461
14462static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14463{
14464	struct alc_spec *spec = codec->spec;
14465	spec->autocfg.hp_pins[0] = 0x21;
14466	spec->autocfg.speaker_pins[0] = 0x14;
14467	spec->ext_mic.pin = 0x18;
14468	spec->ext_mic.mux_idx = 0;
14469	spec->int_mic.pin = 0x12;
14470	spec->int_mic.mux_idx = 6;
14471	spec->auto_mic = 1;
14472}
14473
14474static void alc269_laptop_inithook(struct hda_codec *codec)
14475{
14476	alc269_speaker_automute(codec);
14477	alc_mic_automute(codec);
14478}
14479
14480/*
14481 * generic initialization of ADC, input mixers and output mixers
14482 */
14483static struct hda_verb alc269_init_verbs[] = {
14484	/*
14485	 * Unmute ADC0 and set the default input to mic-in
14486	 */
14487	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14488
14489	/*
14490	 * Set up output mixers (0x02 - 0x03)
14491	 */
14492	/* set vol=0 to output mixers */
14493	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14494	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14495
14496	/* set up input amps for analog loopback */
14497	/* Amp Indices: DAC = 0, mixer = 1 */
14498	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14499	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14500	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14501	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14502	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14503	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14504
14505	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14506	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14507	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14508	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14509	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14510	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14511	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14512
14513	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14514	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14515
14516	/* FIXME: use Mux-type input source selection */
14517	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14518	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14519	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14520
14521	/* set EAPD */
14522	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14523	{ }
14524};
14525
14526static struct hda_verb alc269vb_init_verbs[] = {
14527	/*
14528	 * Unmute ADC0 and set the default input to mic-in
14529	 */
14530	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14531
14532	/*
14533	 * Set up output mixers (0x02 - 0x03)
14534	 */
14535	/* set vol=0 to output mixers */
14536	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14537	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14538
14539	/* set up input amps for analog loopback */
14540	/* Amp Indices: DAC = 0, mixer = 1 */
14541	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14542	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14543	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14544	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14545	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14546	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14547
14548	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14549	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14550	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14551	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14552	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14553	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14554	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14555
14556	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14557	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14558
14559	/* FIXME: use Mux-type input source selection */
14560	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14561	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14562	{0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14563
14564	/* set EAPD */
14565	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14566	{ }
14567};
14568
14569#define alc269_auto_create_multi_out_ctls \
14570	alc268_auto_create_multi_out_ctls
14571#define alc269_auto_create_input_ctls \
14572	alc268_auto_create_input_ctls
14573
14574#ifdef CONFIG_SND_HDA_POWER_SAVE
14575#define alc269_loopbacks	alc880_loopbacks
14576#endif
14577
14578/* pcm configuration: identical with ALC880 */
14579#define alc269_pcm_analog_playback	alc880_pcm_analog_playback
14580#define alc269_pcm_analog_capture	alc880_pcm_analog_capture
14581#define alc269_pcm_digital_playback	alc880_pcm_digital_playback
14582#define alc269_pcm_digital_capture	alc880_pcm_digital_capture
14583
14584static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14585	.substreams = 1,
14586	.channels_min = 2,
14587	.channels_max = 8,
14588	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14589	/* NID is set in alc_build_pcms */
14590	.ops = {
14591		.open = alc880_playback_pcm_open,
14592		.prepare = alc880_playback_pcm_prepare,
14593		.cleanup = alc880_playback_pcm_cleanup
14594	},
14595};
14596
14597static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14598	.substreams = 1,
14599	.channels_min = 2,
14600	.channels_max = 2,
14601	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14602	/* NID is set in alc_build_pcms */
14603};
14604
14605#ifdef CONFIG_SND_HDA_POWER_SAVE
14606static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14607{
14608	switch (codec->subsystem_id) {
14609	case 0x103c1586:
14610		return 1;
14611	}
14612	return 0;
14613}
14614
14615static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14616{
14617	/* update mute-LED according to the speaker mute state */
14618	if (nid == 0x01 || nid == 0x14) {
14619		int pinval;
14620		if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14621		    HDA_AMP_MUTE)
14622			pinval = 0x24;
14623		else
14624			pinval = 0x20;
14625		/* mic2 vref pin is used for mute LED control */
14626		snd_hda_codec_update_cache(codec, 0x19, 0,
14627					   AC_VERB_SET_PIN_WIDGET_CONTROL,
14628					   pinval);
14629	}
14630	return alc_check_power_status(codec, nid);
14631}
14632#endif /* CONFIG_SND_HDA_POWER_SAVE */
14633
14634static int alc275_setup_dual_adc(struct hda_codec *codec)
14635{
14636	struct alc_spec *spec = codec->spec;
14637
14638	if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14639		return 0;
14640	if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14641	    (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14642		if (spec->ext_mic.pin <= 0x12) {
14643			spec->private_adc_nids[0] = 0x08;
14644			spec->private_adc_nids[1] = 0x11;
14645			spec->private_capsrc_nids[0] = 0x23;
14646			spec->private_capsrc_nids[1] = 0x22;
14647		} else {
14648			spec->private_adc_nids[0] = 0x11;
14649			spec->private_adc_nids[1] = 0x08;
14650			spec->private_capsrc_nids[0] = 0x22;
14651			spec->private_capsrc_nids[1] = 0x23;
14652		}
14653		spec->adc_nids = spec->private_adc_nids;
14654		spec->capsrc_nids = spec->private_capsrc_nids;
14655		spec->num_adc_nids = 2;
14656		spec->dual_adc_switch = 1;
14657		snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14658			    spec->adc_nids[0], spec->adc_nids[1]);
14659		return 1;
14660	}
14661	return 0;
14662}
14663
14664/* different alc269-variants */
14665enum {
14666	ALC269_TYPE_NORMAL,
14667	ALC269_TYPE_ALC258,
14668	ALC269_TYPE_ALC259,
14669	ALC269_TYPE_ALC269VB,
14670	ALC269_TYPE_ALC270,
14671	ALC269_TYPE_ALC271X,
14672};
14673
14674/*
14675 * BIOS auto configuration
14676 */
14677static int alc269_parse_auto_config(struct hda_codec *codec)
14678{
14679	struct alc_spec *spec = codec->spec;
14680	int err;
14681	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14682
14683	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14684					   alc269_ignore);
14685	if (err < 0)
14686		return err;
14687
14688	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14689	if (err < 0)
14690		return err;
14691	if (spec->codec_variant == ALC269_TYPE_NORMAL)
14692		err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14693	else
14694		err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14695						 0x22, 0);
14696	if (err < 0)
14697		return err;
14698
14699	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14700
14701	alc_auto_parse_digital(codec);
14702
14703	if (spec->kctls.list)
14704		add_mixer(spec, spec->kctls.list);
14705
14706	if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14707		add_verb(spec, alc269vb_init_verbs);
14708		alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14709	} else {
14710		add_verb(spec, alc269_init_verbs);
14711		alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14712	}
14713
14714	spec->num_mux_defs = 1;
14715	spec->input_mux = &spec->private_imux[0];
14716
14717	if (!alc275_setup_dual_adc(codec))
14718		fillup_priv_adc_nids(codec, alc269_adc_candidates,
14719				     sizeof(alc269_adc_candidates));
14720
14721	/* set default input source */
14722	if (!spec->dual_adc_switch)
14723		select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14724					spec->input_mux->items[0].index);
14725
14726	err = alc_auto_add_mic_boost(codec);
14727	if (err < 0)
14728		return err;
14729
14730	if (!spec->cap_mixer && !spec->no_analog)
14731		set_capture_mixer(codec);
14732
14733	return 1;
14734}
14735
14736#define alc269_auto_init_multi_out	alc268_auto_init_multi_out
14737#define alc269_auto_init_hp_out		alc268_auto_init_hp_out
14738#define alc269_auto_init_analog_input	alc882_auto_init_analog_input
14739
14740
14741/* init callback for auto-configuration model -- overriding the default init */
14742static void alc269_auto_init(struct hda_codec *codec)
14743{
14744	struct alc_spec *spec = codec->spec;
14745	alc269_auto_init_multi_out(codec);
14746	alc269_auto_init_hp_out(codec);
14747	alc269_auto_init_analog_input(codec);
14748	alc_auto_init_digital(codec);
14749	if (spec->unsol_event)
14750		alc_inithook(codec);
14751}
14752
14753#ifdef SND_HDA_NEEDS_RESUME
14754static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14755{
14756	int val = alc_read_coef_idx(codec, 0x04);
14757	if (power_up)
14758		val |= 1 << 11;
14759	else
14760		val &= ~(1 << 11);
14761	alc_write_coef_idx(codec, 0x04, val);
14762}
14763
14764#ifdef CONFIG_SND_HDA_POWER_SAVE
14765static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14766{
14767	struct alc_spec *spec = codec->spec;
14768
14769	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14770		alc269_toggle_power_output(codec, 0);
14771	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14772		alc269_toggle_power_output(codec, 0);
14773		msleep(150);
14774	}
14775
14776	alc_shutup(codec);
14777	if (spec && spec->power_hook)
14778		spec->power_hook(codec);
14779	return 0;
14780}
14781#endif /* CONFIG_SND_HDA_POWER_SAVE */
14782
14783static int alc269_resume(struct hda_codec *codec)
14784{
14785	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14786		alc269_toggle_power_output(codec, 0);
14787		msleep(150);
14788	}
14789
14790	codec->patch_ops.init(codec);
14791
14792	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14793		alc269_toggle_power_output(codec, 1);
14794		msleep(200);
14795	}
14796
14797	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14798		alc269_toggle_power_output(codec, 1);
14799
14800	snd_hda_codec_resume_amp(codec);
14801	snd_hda_codec_resume_cache(codec);
14802	hda_call_check_power_status(codec, 0x01);
14803	return 0;
14804}
14805#endif /* SND_HDA_NEEDS_RESUME */
14806
14807enum {
14808	ALC269_FIXUP_SONY_VAIO,
14809	ALC275_FIX_SONY_VAIO_GPIO2,
14810	ALC269_FIXUP_DELL_M101Z,
14811	ALC269_FIXUP_SKU_IGNORE,
14812	ALC269_FIXUP_ASUS_G73JW,
14813};
14814
14815static const struct alc_fixup alc269_fixups[] = {
14816	[ALC269_FIXUP_SONY_VAIO] = {
14817		.verbs = (const struct hda_verb[]) {
14818			{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14819			{}
14820		}
14821	},
14822	[ALC275_FIX_SONY_VAIO_GPIO2] = {
14823		.verbs = (const struct hda_verb[]) {
14824			{0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14825			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14826			{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14827			{ }
14828		}
14829	},
14830	[ALC269_FIXUP_DELL_M101Z] = {
14831		.verbs = (const struct hda_verb[]) {
14832			/* Enables internal speaker */
14833			{0x20, AC_VERB_SET_COEF_INDEX, 13},
14834			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14835			{}
14836		}
14837	},
14838	[ALC269_FIXUP_SKU_IGNORE] = {
14839		.sku = ALC_FIXUP_SKU_IGNORE,
14840	},
14841	[ALC269_FIXUP_ASUS_G73JW] = {
14842		.pins = (const struct alc_pincfg[]) {
14843			{ 0x17, 0x99130111 }, /* subwoofer */
14844			{ }
14845		}
14846	},
14847};
14848
14849static struct snd_pci_quirk alc269_fixup_tbl[] = {
14850	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14851	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIX_SONY_VAIO_GPIO2),
14852	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIX_SONY_VAIO_GPIO2),
14853	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIX_SONY_VAIO_GPIO2),
14854	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14855	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14856	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14857	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14858	{}
14859};
14860
14861
14862/*
14863 * configuration and preset
14864 */
14865static const char *alc269_models[ALC269_MODEL_LAST] = {
14866	[ALC269_BASIC]			= "basic",
14867	[ALC269_QUANTA_FL1]		= "quanta",
14868	[ALC269_AMIC]			= "laptop-amic",
14869	[ALC269_DMIC]			= "laptop-dmic",
14870	[ALC269_FUJITSU]		= "fujitsu",
14871	[ALC269_LIFEBOOK]		= "lifebook",
14872	[ALC269_AUTO]			= "auto",
14873};
14874
14875static struct snd_pci_quirk alc269_cfg_tbl[] = {
14876	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14877	SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14878	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14879		      ALC269_AMIC),
14880	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14881	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14882	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14883	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14884	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14885	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14886	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14887	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14888	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14889	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14890	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14891	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14892	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14893	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14894	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14895	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14896	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14897	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14898	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14899	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14900	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14901	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14902	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14903	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14904	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14905	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14906	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14907	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14908	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14909	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14910	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14911	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14912	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14913	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14914	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14915	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14916	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14917		      ALC269_DMIC),
14918	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14919		      ALC269_DMIC),
14920	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14921	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14922	SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14923	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14924	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14925	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14926	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14927	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14928	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14929	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14930	{}
14931};
14932
14933static struct alc_config_preset alc269_presets[] = {
14934	[ALC269_BASIC] = {
14935		.mixers = { alc269_base_mixer },
14936		.init_verbs = { alc269_init_verbs },
14937		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14938		.dac_nids = alc269_dac_nids,
14939		.hp_nid = 0x03,
14940		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14941		.channel_mode = alc269_modes,
14942		.input_mux = &alc269_capture_source,
14943	},
14944	[ALC269_QUANTA_FL1] = {
14945		.mixers = { alc269_quanta_fl1_mixer },
14946		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14947		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14948		.dac_nids = alc269_dac_nids,
14949		.hp_nid = 0x03,
14950		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14951		.channel_mode = alc269_modes,
14952		.input_mux = &alc269_capture_source,
14953		.unsol_event = alc269_quanta_fl1_unsol_event,
14954		.setup = alc269_quanta_fl1_setup,
14955		.init_hook = alc269_quanta_fl1_init_hook,
14956	},
14957	[ALC269_AMIC] = {
14958		.mixers = { alc269_laptop_mixer },
14959		.cap_mixer = alc269_laptop_analog_capture_mixer,
14960		.init_verbs = { alc269_init_verbs,
14961				alc269_laptop_amic_init_verbs },
14962		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14963		.dac_nids = alc269_dac_nids,
14964		.hp_nid = 0x03,
14965		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14966		.channel_mode = alc269_modes,
14967		.unsol_event = alc269_laptop_unsol_event,
14968		.setup = alc269_laptop_amic_setup,
14969		.init_hook = alc269_laptop_inithook,
14970	},
14971	[ALC269_DMIC] = {
14972		.mixers = { alc269_laptop_mixer },
14973		.cap_mixer = alc269_laptop_digital_capture_mixer,
14974		.init_verbs = { alc269_init_verbs,
14975				alc269_laptop_dmic_init_verbs },
14976		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14977		.dac_nids = alc269_dac_nids,
14978		.hp_nid = 0x03,
14979		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14980		.channel_mode = alc269_modes,
14981		.unsol_event = alc269_laptop_unsol_event,
14982		.setup = alc269_laptop_dmic_setup,
14983		.init_hook = alc269_laptop_inithook,
14984	},
14985	[ALC269VB_AMIC] = {
14986		.mixers = { alc269vb_laptop_mixer },
14987		.cap_mixer = alc269vb_laptop_analog_capture_mixer,
14988		.init_verbs = { alc269vb_init_verbs,
14989				alc269vb_laptop_amic_init_verbs },
14990		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
14991		.dac_nids = alc269_dac_nids,
14992		.hp_nid = 0x03,
14993		.num_channel_mode = ARRAY_SIZE(alc269_modes),
14994		.channel_mode = alc269_modes,
14995		.unsol_event = alc269_laptop_unsol_event,
14996		.setup = alc269vb_laptop_amic_setup,
14997		.init_hook = alc269_laptop_inithook,
14998	},
14999	[ALC269VB_DMIC] = {
15000		.mixers = { alc269vb_laptop_mixer },
15001		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
15002		.init_verbs = { alc269vb_init_verbs,
15003				alc269vb_laptop_dmic_init_verbs },
15004		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15005		.dac_nids = alc269_dac_nids,
15006		.hp_nid = 0x03,
15007		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15008		.channel_mode = alc269_modes,
15009		.unsol_event = alc269_laptop_unsol_event,
15010		.setup = alc269vb_laptop_dmic_setup,
15011		.init_hook = alc269_laptop_inithook,
15012	},
15013	[ALC269_FUJITSU] = {
15014		.mixers = { alc269_fujitsu_mixer },
15015		.cap_mixer = alc269_laptop_digital_capture_mixer,
15016		.init_verbs = { alc269_init_verbs,
15017				alc269_laptop_dmic_init_verbs },
15018		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15019		.dac_nids = alc269_dac_nids,
15020		.hp_nid = 0x03,
15021		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15022		.channel_mode = alc269_modes,
15023		.unsol_event = alc269_laptop_unsol_event,
15024		.setup = alc269_laptop_dmic_setup,
15025		.init_hook = alc269_laptop_inithook,
15026	},
15027	[ALC269_LIFEBOOK] = {
15028		.mixers = { alc269_lifebook_mixer },
15029		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15030		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15031		.dac_nids = alc269_dac_nids,
15032		.hp_nid = 0x03,
15033		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15034		.channel_mode = alc269_modes,
15035		.input_mux = &alc269_capture_source,
15036		.unsol_event = alc269_lifebook_unsol_event,
15037		.init_hook = alc269_lifebook_init_hook,
15038	},
15039	[ALC271_ACER] = {
15040		.mixers = { alc269_asus_mixer },
15041		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
15042		.init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15043		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15044		.dac_nids = alc269_dac_nids,
15045		.adc_nids = alc262_dmic_adc_nids,
15046		.num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15047		.capsrc_nids = alc262_dmic_capsrc_nids,
15048		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15049		.channel_mode = alc269_modes,
15050		.input_mux = &alc269_capture_source,
15051		.dig_out_nid = ALC880_DIGOUT_NID,
15052		.unsol_event = alc_sku_unsol_event,
15053		.setup = alc269vb_laptop_dmic_setup,
15054		.init_hook = alc_inithook,
15055	},
15056};
15057
15058static int alc269_fill_coef(struct hda_codec *codec)
15059{
15060	int val;
15061
15062	if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15063		alc_write_coef_idx(codec, 0xf, 0x960b);
15064		alc_write_coef_idx(codec, 0xe, 0x8817);
15065	}
15066
15067	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15068		alc_write_coef_idx(codec, 0xf, 0x960b);
15069		alc_write_coef_idx(codec, 0xe, 0x8814);
15070	}
15071
15072	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15073		val = alc_read_coef_idx(codec, 0x04);
15074		/* Power up output pin */
15075		alc_write_coef_idx(codec, 0x04, val | (1<<11));
15076	}
15077
15078	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15079		val = alc_read_coef_idx(codec, 0xd);
15080		if ((val & 0x0c00) >> 10 != 0x1) {
15081			/* Capless ramp up clock control */
15082			alc_write_coef_idx(codec, 0xd, val | 1<<10);
15083		}
15084		val = alc_read_coef_idx(codec, 0x17);
15085		if ((val & 0x01c0) >> 6 != 0x4) {
15086			/* Class D power on reset */
15087			alc_write_coef_idx(codec, 0x17, val | 1<<7);
15088		}
15089	}
15090	return 0;
15091}
15092
15093static int patch_alc269(struct hda_codec *codec)
15094{
15095	struct alc_spec *spec;
15096	int board_config, coef;
15097	int err;
15098
15099	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15100	if (spec == NULL)
15101		return -ENOMEM;
15102
15103	codec->spec = spec;
15104
15105	alc_auto_parse_customize_define(codec);
15106
15107	coef = alc_read_coef_idx(codec, 0);
15108	if ((coef & 0x00f0) == 0x0010) {
15109		if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15110		    spec->cdefine.platform_type == 1) {
15111			alc_codec_rename(codec, "ALC271X");
15112			spec->codec_variant = ALC269_TYPE_ALC271X;
15113		} else if ((coef & 0xf000) == 0x1000) {
15114			spec->codec_variant = ALC269_TYPE_ALC270;
15115		} else if ((coef & 0xf000) == 0x2000) {
15116			alc_codec_rename(codec, "ALC259");
15117			spec->codec_variant = ALC269_TYPE_ALC259;
15118		} else if ((coef & 0xf000) == 0x3000) {
15119			alc_codec_rename(codec, "ALC258");
15120			spec->codec_variant = ALC269_TYPE_ALC258;
15121		} else {
15122			alc_codec_rename(codec, "ALC269VB");
15123			spec->codec_variant = ALC269_TYPE_ALC269VB;
15124		}
15125	} else
15126		alc_fix_pll_init(codec, 0x20, 0x04, 15);
15127
15128	alc269_fill_coef(codec);
15129
15130	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15131						  alc269_models,
15132						  alc269_cfg_tbl);
15133
15134	if (board_config < 0) {
15135		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15136		       codec->chip_name);
15137		board_config = ALC269_AUTO;
15138	}
15139
15140	if (board_config == ALC269_AUTO)
15141		alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
15142
15143	if (board_config == ALC269_AUTO) {
15144		/* automatic parse from the BIOS config */
15145		err = alc269_parse_auto_config(codec);
15146		if (err < 0) {
15147			alc_free(codec);
15148			return err;
15149		} else if (!err) {
15150			printk(KERN_INFO
15151			       "hda_codec: Cannot set up configuration "
15152			       "from BIOS.  Using base mode...\n");
15153			board_config = ALC269_BASIC;
15154		}
15155	}
15156
15157	if (has_cdefine_beep(codec)) {
15158		err = snd_hda_attach_beep_device(codec, 0x1);
15159		if (err < 0) {
15160			alc_free(codec);
15161			return err;
15162		}
15163	}
15164
15165	if (board_config != ALC269_AUTO)
15166		setup_preset(codec, &alc269_presets[board_config]);
15167
15168	if (board_config == ALC269_QUANTA_FL1) {
15169		/* Due to a hardware problem on Lenovo Ideadpad, we need to
15170		 * fix the sample rate of analog I/O to 44.1kHz
15171		 */
15172		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15173		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15174	} else if (spec->dual_adc_switch) {
15175		spec->stream_analog_playback = &alc269_pcm_analog_playback;
15176		/* switch ADC dynamically */
15177		spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15178	} else {
15179		spec->stream_analog_playback = &alc269_pcm_analog_playback;
15180		spec->stream_analog_capture = &alc269_pcm_analog_capture;
15181	}
15182	spec->stream_digital_playback = &alc269_pcm_digital_playback;
15183	spec->stream_digital_capture = &alc269_pcm_digital_capture;
15184
15185	if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15186		if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15187			spec->adc_nids = alc269_adc_nids;
15188			spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15189			spec->capsrc_nids = alc269_capsrc_nids;
15190		} else {
15191			spec->adc_nids = alc269vb_adc_nids;
15192			spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15193			spec->capsrc_nids = alc269vb_capsrc_nids;
15194		}
15195	}
15196
15197	if (!spec->cap_mixer)
15198		set_capture_mixer(codec);
15199	if (has_cdefine_beep(codec))
15200		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15201
15202	if (board_config == ALC269_AUTO)
15203		alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
15204
15205	spec->vmaster_nid = 0x02;
15206
15207	codec->patch_ops = alc_patch_ops;
15208#ifdef CONFIG_SND_HDA_POWER_SAVE
15209	codec->patch_ops.suspend = alc269_suspend;
15210#endif
15211#ifdef SND_HDA_NEEDS_RESUME
15212	codec->patch_ops.resume = alc269_resume;
15213#endif
15214	if (board_config == ALC269_AUTO)
15215		spec->init_hook = alc269_auto_init;
15216
15217	alc_init_jacks(codec);
15218#ifdef CONFIG_SND_HDA_POWER_SAVE
15219	if (!spec->loopback.amplist)
15220		spec->loopback.amplist = alc269_loopbacks;
15221	if (alc269_mic2_for_mute_led(codec))
15222		codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15223#endif
15224
15225	return 0;
15226}
15227
15228/*
15229 *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15230 */
15231
15232/*
15233 * set the path ways for 2 channel output
15234 * need to set the codec line out and mic 1 pin widgets to inputs
15235 */
15236static struct hda_verb alc861_threestack_ch2_init[] = {
15237	/* set pin widget 1Ah (line in) for input */
15238	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15239	/* set pin widget 18h (mic1/2) for input, for mic also enable
15240	 * the vref
15241	 */
15242	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15243
15244	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15245#if 0
15246	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15247	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15248#endif
15249	{ } /* end */
15250};
15251/*
15252 * 6ch mode
15253 * need to set the codec line out and mic 1 pin widgets to outputs
15254 */
15255static struct hda_verb alc861_threestack_ch6_init[] = {
15256	/* set pin widget 1Ah (line in) for output (Back Surround)*/
15257	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15258	/* set pin widget 18h (mic1) for output (CLFE)*/
15259	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15260
15261	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15262	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15263
15264	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15265#if 0
15266	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15267	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15268#endif
15269	{ } /* end */
15270};
15271
15272static struct hda_channel_mode alc861_threestack_modes[2] = {
15273	{ 2, alc861_threestack_ch2_init },
15274	{ 6, alc861_threestack_ch6_init },
15275};
15276/* Set mic1 as input and unmute the mixer */
15277static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15278	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15279	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15280	{ } /* end */
15281};
15282/* Set mic1 as output and mute mixer */
15283static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15284	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15285	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15286	{ } /* end */
15287};
15288
15289static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15290	{ 2, alc861_uniwill_m31_ch2_init },
15291	{ 4, alc861_uniwill_m31_ch4_init },
15292};
15293
15294/* Set mic1 and line-in as input and unmute the mixer */
15295static struct hda_verb alc861_asus_ch2_init[] = {
15296	/* set pin widget 1Ah (line in) for input */
15297	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15298	/* set pin widget 18h (mic1/2) for input, for mic also enable
15299	 * the vref
15300	 */
15301	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15302
15303	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15304#if 0
15305	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15306	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15307#endif
15308	{ } /* end */
15309};
15310/* Set mic1 nad line-in as output and mute mixer */
15311static struct hda_verb alc861_asus_ch6_init[] = {
15312	/* set pin widget 1Ah (line in) for output (Back Surround)*/
15313	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15314	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15315	/* set pin widget 18h (mic1) for output (CLFE)*/
15316	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15317	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15318	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15319	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15320
15321	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15322#if 0
15323	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15324	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15325#endif
15326	{ } /* end */
15327};
15328
15329static struct hda_channel_mode alc861_asus_modes[2] = {
15330	{ 2, alc861_asus_ch2_init },
15331	{ 6, alc861_asus_ch6_init },
15332};
15333
15334/* patch-ALC861 */
15335
15336static struct snd_kcontrol_new alc861_base_mixer[] = {
15337        /* output mixer control */
15338	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15339	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15340	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15341	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15342	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15343
15344        /*Input mixer control */
15345	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15346	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15347	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15348	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15349	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15350	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15351	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15352	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15353	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15354	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15355
15356	{ } /* end */
15357};
15358
15359static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15360        /* output mixer control */
15361	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15362	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15363	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15364	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15365	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15366
15367	/* Input mixer control */
15368	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15369	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15370	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15371	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15372	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15373	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15374	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15375	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15376	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15377	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15378
15379	{
15380		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15381		.name = "Channel Mode",
15382		.info = alc_ch_mode_info,
15383		.get = alc_ch_mode_get,
15384		.put = alc_ch_mode_put,
15385                .private_value = ARRAY_SIZE(alc861_threestack_modes),
15386	},
15387	{ } /* end */
15388};
15389
15390static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15391        /* output mixer control */
15392	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15393	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15394	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15395
15396	{ } /* end */
15397};
15398
15399static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15400        /* output mixer control */
15401	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15402	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15403	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15404	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15405	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15406
15407	/* Input mixer control */
15408	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15409	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15410	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15411	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15412	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15413	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15414	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15415	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15416	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15417	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15418
15419	{
15420		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15421		.name = "Channel Mode",
15422		.info = alc_ch_mode_info,
15423		.get = alc_ch_mode_get,
15424		.put = alc_ch_mode_put,
15425                .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15426	},
15427	{ } /* end */
15428};
15429
15430static struct snd_kcontrol_new alc861_asus_mixer[] = {
15431        /* output mixer control */
15432	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15433	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15434	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15435	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15436	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15437
15438	/* Input mixer control */
15439	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15440	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15441	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15442	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15443	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15444	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15445	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15446	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15447	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15448	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15449
15450	{
15451		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15452		.name = "Channel Mode",
15453		.info = alc_ch_mode_info,
15454		.get = alc_ch_mode_get,
15455		.put = alc_ch_mode_put,
15456                .private_value = ARRAY_SIZE(alc861_asus_modes),
15457	},
15458	{ }
15459};
15460
15461/* additional mixer */
15462static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15463	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15464	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15465	{ }
15466};
15467
15468/*
15469 * generic initialization of ADC, input mixers and output mixers
15470 */
15471static struct hda_verb alc861_base_init_verbs[] = {
15472	/*
15473	 * Unmute ADC0 and set the default input to mic-in
15474	 */
15475	/* port-A for surround (rear panel) */
15476	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15477	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15478	/* port-B for mic-in (rear panel) with vref */
15479	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15480	/* port-C for line-in (rear panel) */
15481	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15482	/* port-D for Front */
15483	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15484	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15485	/* port-E for HP out (front panel) */
15486	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15487	/* route front PCM to HP */
15488	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15489	/* port-F for mic-in (front panel) with vref */
15490	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15491	/* port-G for CLFE (rear panel) */
15492	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15493	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15494	/* port-H for side (rear panel) */
15495	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15496	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15497	/* CD-in */
15498	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15499	/* route front mic to ADC1*/
15500	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15501	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15502
15503	/* Unmute DAC0~3 & spdif out*/
15504	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15505	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15506	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15507	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15508	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15509
15510	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15511	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15512        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15513	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15514        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15515
15516	/* Unmute Stereo Mixer 15 */
15517	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15518	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15519	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15520	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15521
15522	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15523	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15524	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15525	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15526	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15527	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15528	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15529	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15530	/* hp used DAC 3 (Front) */
15531	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15532        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15533
15534	{ }
15535};
15536
15537static struct hda_verb alc861_threestack_init_verbs[] = {
15538	/*
15539	 * Unmute ADC0 and set the default input to mic-in
15540	 */
15541	/* port-A for surround (rear panel) */
15542	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15543	/* port-B for mic-in (rear panel) with vref */
15544	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15545	/* port-C for line-in (rear panel) */
15546	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15547	/* port-D for Front */
15548	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15549	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15550	/* port-E for HP out (front panel) */
15551	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15552	/* route front PCM to HP */
15553	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15554	/* port-F for mic-in (front panel) with vref */
15555	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15556	/* port-G for CLFE (rear panel) */
15557	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15558	/* port-H for side (rear panel) */
15559	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15560	/* CD-in */
15561	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15562	/* route front mic to ADC1*/
15563	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15564	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15565	/* Unmute DAC0~3 & spdif out*/
15566	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15567	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15568	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15569	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15570	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15571
15572	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15573	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15574        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15575	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15576        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15577
15578	/* Unmute Stereo Mixer 15 */
15579	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15580	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15581	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15582	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15583
15584	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15585	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15586	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15587	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15588	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15589	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15590	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15591	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15592	/* hp used DAC 3 (Front) */
15593	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15594        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15595	{ }
15596};
15597
15598static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15599	/*
15600	 * Unmute ADC0 and set the default input to mic-in
15601	 */
15602	/* port-A for surround (rear panel) */
15603	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15604	/* port-B for mic-in (rear panel) with vref */
15605	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15606	/* port-C for line-in (rear panel) */
15607	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15608	/* port-D for Front */
15609	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15610	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15611	/* port-E for HP out (front panel) */
15612	/* this has to be set to VREF80 */
15613	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15614	/* route front PCM to HP */
15615	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15616	/* port-F for mic-in (front panel) with vref */
15617	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15618	/* port-G for CLFE (rear panel) */
15619	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15620	/* port-H for side (rear panel) */
15621	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15622	/* CD-in */
15623	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15624	/* route front mic to ADC1*/
15625	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15626	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15627	/* Unmute DAC0~3 & spdif out*/
15628	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15629	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15630	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15631	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15632	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15633
15634	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15635	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15636        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15637	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15638        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15639
15640	/* Unmute Stereo Mixer 15 */
15641	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15642	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15643	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15644	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15645
15646	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15647	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15648	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15649	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15650	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15651	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15652	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15653	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15654	/* hp used DAC 3 (Front) */
15655	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15656        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15657	{ }
15658};
15659
15660static struct hda_verb alc861_asus_init_verbs[] = {
15661	/*
15662	 * Unmute ADC0 and set the default input to mic-in
15663	 */
15664	/* port-A for surround (rear panel)
15665	 * according to codec#0 this is the HP jack
15666	 */
15667	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15668	/* route front PCM to HP */
15669	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15670	/* port-B for mic-in (rear panel) with vref */
15671	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15672	/* port-C for line-in (rear panel) */
15673	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15674	/* port-D for Front */
15675	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15676	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15677	/* port-E for HP out (front panel) */
15678	/* this has to be set to VREF80 */
15679	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15680	/* route front PCM to HP */
15681	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15682	/* port-F for mic-in (front panel) with vref */
15683	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15684	/* port-G for CLFE (rear panel) */
15685	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15686	/* port-H for side (rear panel) */
15687	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15688	/* CD-in */
15689	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15690	/* route front mic to ADC1*/
15691	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15692	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15693	/* Unmute DAC0~3 & spdif out*/
15694	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15695	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15696	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15697	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15698	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15699	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15700	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15701        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15702	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15703        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15704
15705	/* Unmute Stereo Mixer 15 */
15706	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15707	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15708	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15709	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15710
15711	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15712	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15713	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15714	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15715	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15716	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15717	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15718	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15719	/* hp used DAC 3 (Front) */
15720	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15721	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15722	{ }
15723};
15724
15725/* additional init verbs for ASUS laptops */
15726static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15727	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15728	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15729	{ }
15730};
15731
15732/*
15733 * generic initialization of ADC, input mixers and output mixers
15734 */
15735static struct hda_verb alc861_auto_init_verbs[] = {
15736	/*
15737	 * Unmute ADC0 and set the default input to mic-in
15738	 */
15739	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15740	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15741
15742	/* Unmute DAC0~3 & spdif out*/
15743	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15744	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15745	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15746	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15747	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15748
15749	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15750	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15751	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15752	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15753	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15754
15755	/* Unmute Stereo Mixer 15 */
15756	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15757	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15758	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15759	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15760
15761	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15762	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15763	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15764	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15765	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15766	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15767	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15768	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15769
15770	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15771	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15772	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15773	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15774	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15775	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15776	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15777	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15778
15779	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
15780
15781	{ }
15782};
15783
15784static struct hda_verb alc861_toshiba_init_verbs[] = {
15785	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15786
15787	{ }
15788};
15789
15790/* toggle speaker-output according to the hp-jack state */
15791static void alc861_toshiba_automute(struct hda_codec *codec)
15792{
15793	unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15794
15795	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15796				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15797	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15798				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15799}
15800
15801static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15802				       unsigned int res)
15803{
15804	if ((res >> 26) == ALC880_HP_EVENT)
15805		alc861_toshiba_automute(codec);
15806}
15807
15808/* pcm configuration: identical with ALC880 */
15809#define alc861_pcm_analog_playback	alc880_pcm_analog_playback
15810#define alc861_pcm_analog_capture	alc880_pcm_analog_capture
15811#define alc861_pcm_digital_playback	alc880_pcm_digital_playback
15812#define alc861_pcm_digital_capture	alc880_pcm_digital_capture
15813
15814
15815#define ALC861_DIGOUT_NID	0x07
15816
15817static struct hda_channel_mode alc861_8ch_modes[1] = {
15818	{ 8, NULL }
15819};
15820
15821static hda_nid_t alc861_dac_nids[4] = {
15822	/* front, surround, clfe, side */
15823	0x03, 0x06, 0x05, 0x04
15824};
15825
15826static hda_nid_t alc660_dac_nids[3] = {
15827	/* front, clfe, surround */
15828	0x03, 0x05, 0x06
15829};
15830
15831static hda_nid_t alc861_adc_nids[1] = {
15832	/* ADC0-2 */
15833	0x08,
15834};
15835
15836static struct hda_input_mux alc861_capture_source = {
15837	.num_items = 5,
15838	.items = {
15839		{ "Mic", 0x0 },
15840		{ "Front Mic", 0x3 },
15841		{ "Line", 0x1 },
15842		{ "CD", 0x4 },
15843		{ "Mixer", 0x5 },
15844	},
15845};
15846
15847static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15848{
15849	struct alc_spec *spec = codec->spec;
15850	hda_nid_t mix, srcs[5];
15851	int i, j, num;
15852
15853	if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15854		return 0;
15855	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15856	if (num < 0)
15857		return 0;
15858	for (i = 0; i < num; i++) {
15859		unsigned int type;
15860		type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15861		if (type != AC_WID_AUD_OUT)
15862			continue;
15863		for (j = 0; j < spec->multiout.num_dacs; j++)
15864			if (spec->multiout.dac_nids[j] == srcs[i])
15865				break;
15866		if (j >= spec->multiout.num_dacs)
15867			return srcs[i];
15868	}
15869	return 0;
15870}
15871
15872/* fill in the dac_nids table from the parsed pin configuration */
15873static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15874				     const struct auto_pin_cfg *cfg)
15875{
15876	struct alc_spec *spec = codec->spec;
15877	int i;
15878	hda_nid_t nid, dac;
15879
15880	spec->multiout.dac_nids = spec->private_dac_nids;
15881	for (i = 0; i < cfg->line_outs; i++) {
15882		nid = cfg->line_out_pins[i];
15883		dac = alc861_look_for_dac(codec, nid);
15884		if (!dac)
15885			continue;
15886		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15887	}
15888	return 0;
15889}
15890
15891static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15892				hda_nid_t nid, unsigned int chs)
15893{
15894	return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
15895			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15896}
15897
15898/* add playback controls from the parsed DAC table */
15899static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15900					     const struct auto_pin_cfg *cfg)
15901{
15902	struct alc_spec *spec = codec->spec;
15903	static const char *chname[4] = {
15904		"Front", "Surround", NULL /*CLFE*/, "Side"
15905	};
15906	hda_nid_t nid;
15907	int i, err;
15908
15909	if (cfg->line_outs == 1) {
15910		const char *pfx = NULL;
15911		if (!cfg->hp_outs)
15912			pfx = "Master";
15913		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15914			pfx = "Speaker";
15915		if (pfx) {
15916			nid = spec->multiout.dac_nids[0];
15917			return alc861_create_out_sw(codec, pfx, nid, 3);
15918		}
15919	}
15920
15921	for (i = 0; i < cfg->line_outs; i++) {
15922		nid = spec->multiout.dac_nids[i];
15923		if (!nid)
15924			continue;
15925		if (i == 2) {
15926			/* Center/LFE */
15927			err = alc861_create_out_sw(codec, "Center", nid, 1);
15928			if (err < 0)
15929				return err;
15930			err = alc861_create_out_sw(codec, "LFE", nid, 2);
15931			if (err < 0)
15932				return err;
15933		} else {
15934			err = alc861_create_out_sw(codec, chname[i], nid, 3);
15935			if (err < 0)
15936				return err;
15937		}
15938	}
15939	return 0;
15940}
15941
15942static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15943{
15944	struct alc_spec *spec = codec->spec;
15945	int err;
15946	hda_nid_t nid;
15947
15948	if (!pin)
15949		return 0;
15950
15951	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15952		nid = alc861_look_for_dac(codec, pin);
15953		if (nid) {
15954			err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15955			if (err < 0)
15956				return err;
15957			spec->multiout.hp_nid = nid;
15958		}
15959	}
15960	return 0;
15961}
15962
15963/* create playback/capture controls for input pins */
15964static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15965						const struct auto_pin_cfg *cfg)
15966{
15967	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15968}
15969
15970static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15971					      hda_nid_t nid,
15972					      int pin_type, hda_nid_t dac)
15973{
15974	hda_nid_t mix, srcs[5];
15975	int i, num;
15976
15977	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15978			    pin_type);
15979	snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15980			    AMP_OUT_UNMUTE);
15981	if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15982		return;
15983	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15984	if (num < 0)
15985		return;
15986	for (i = 0; i < num; i++) {
15987		unsigned int mute;
15988		if (srcs[i] == dac || srcs[i] == 0x15)
15989			mute = AMP_IN_UNMUTE(i);
15990		else
15991			mute = AMP_IN_MUTE(i);
15992		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15993				    mute);
15994	}
15995}
15996
15997static void alc861_auto_init_multi_out(struct hda_codec *codec)
15998{
15999	struct alc_spec *spec = codec->spec;
16000	int i;
16001
16002	for (i = 0; i < spec->autocfg.line_outs; i++) {
16003		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16004		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16005		if (nid)
16006			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16007							  spec->multiout.dac_nids[i]);
16008	}
16009}
16010
16011static void alc861_auto_init_hp_out(struct hda_codec *codec)
16012{
16013	struct alc_spec *spec = codec->spec;
16014
16015	if (spec->autocfg.hp_outs)
16016		alc861_auto_set_output_and_unmute(codec,
16017						  spec->autocfg.hp_pins[0],
16018						  PIN_HP,
16019						  spec->multiout.hp_nid);
16020	if (spec->autocfg.speaker_outs)
16021		alc861_auto_set_output_and_unmute(codec,
16022						  spec->autocfg.speaker_pins[0],
16023						  PIN_OUT,
16024						  spec->multiout.dac_nids[0]);
16025}
16026
16027static void alc861_auto_init_analog_input(struct hda_codec *codec)
16028{
16029	struct alc_spec *spec = codec->spec;
16030	struct auto_pin_cfg *cfg = &spec->autocfg;
16031	int i;
16032
16033	for (i = 0; i < cfg->num_inputs; i++) {
16034		hda_nid_t nid = cfg->inputs[i].pin;
16035		if (nid >= 0x0c && nid <= 0x11)
16036			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16037	}
16038}
16039
16040/* parse the BIOS configuration and set up the alc_spec */
16041/* return 1 if successful, 0 if the proper config is not found,
16042 * or a negative error code
16043 */
16044static int alc861_parse_auto_config(struct hda_codec *codec)
16045{
16046	struct alc_spec *spec = codec->spec;
16047	int err;
16048	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16049
16050	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16051					   alc861_ignore);
16052	if (err < 0)
16053		return err;
16054	if (!spec->autocfg.line_outs)
16055		return 0; /* can't find valid BIOS pin config */
16056
16057	err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16058	if (err < 0)
16059		return err;
16060	err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16061	if (err < 0)
16062		return err;
16063	err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16064	if (err < 0)
16065		return err;
16066	err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16067	if (err < 0)
16068		return err;
16069
16070	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16071
16072	alc_auto_parse_digital(codec);
16073
16074	if (spec->kctls.list)
16075		add_mixer(spec, spec->kctls.list);
16076
16077	add_verb(spec, alc861_auto_init_verbs);
16078
16079	spec->num_mux_defs = 1;
16080	spec->input_mux = &spec->private_imux[0];
16081
16082	spec->adc_nids = alc861_adc_nids;
16083	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16084	set_capture_mixer(codec);
16085
16086	alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16087
16088	return 1;
16089}
16090
16091/* additional initialization for auto-configuration model */
16092static void alc861_auto_init(struct hda_codec *codec)
16093{
16094	struct alc_spec *spec = codec->spec;
16095	alc861_auto_init_multi_out(codec);
16096	alc861_auto_init_hp_out(codec);
16097	alc861_auto_init_analog_input(codec);
16098	alc_auto_init_digital(codec);
16099	if (spec->unsol_event)
16100		alc_inithook(codec);
16101}
16102
16103#ifdef CONFIG_SND_HDA_POWER_SAVE
16104static struct hda_amp_list alc861_loopbacks[] = {
16105	{ 0x15, HDA_INPUT, 0 },
16106	{ 0x15, HDA_INPUT, 1 },
16107	{ 0x15, HDA_INPUT, 2 },
16108	{ 0x15, HDA_INPUT, 3 },
16109	{ } /* end */
16110};
16111#endif
16112
16113
16114/*
16115 * configuration and preset
16116 */
16117static const char *alc861_models[ALC861_MODEL_LAST] = {
16118	[ALC861_3ST]		= "3stack",
16119	[ALC660_3ST]		= "3stack-660",
16120	[ALC861_3ST_DIG]	= "3stack-dig",
16121	[ALC861_6ST_DIG]	= "6stack-dig",
16122	[ALC861_UNIWILL_M31]	= "uniwill-m31",
16123	[ALC861_TOSHIBA]	= "toshiba",
16124	[ALC861_ASUS]		= "asus",
16125	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
16126	[ALC861_AUTO]		= "auto",
16127};
16128
16129static struct snd_pci_quirk alc861_cfg_tbl[] = {
16130	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16131	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16132	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16133	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16134	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16135	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16136	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16137	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16138	 *        Any other models that need this preset?
16139	 */
16140	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16141	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16142	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16143	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16144	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16145	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16146	/* FIXME: the below seems conflict */
16147	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16148	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16149	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16150	{}
16151};
16152
16153static struct alc_config_preset alc861_presets[] = {
16154	[ALC861_3ST] = {
16155		.mixers = { alc861_3ST_mixer },
16156		.init_verbs = { alc861_threestack_init_verbs },
16157		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16158		.dac_nids = alc861_dac_nids,
16159		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16160		.channel_mode = alc861_threestack_modes,
16161		.need_dac_fix = 1,
16162		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16163		.adc_nids = alc861_adc_nids,
16164		.input_mux = &alc861_capture_source,
16165	},
16166	[ALC861_3ST_DIG] = {
16167		.mixers = { alc861_base_mixer },
16168		.init_verbs = { alc861_threestack_init_verbs },
16169		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16170		.dac_nids = alc861_dac_nids,
16171		.dig_out_nid = ALC861_DIGOUT_NID,
16172		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16173		.channel_mode = alc861_threestack_modes,
16174		.need_dac_fix = 1,
16175		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16176		.adc_nids = alc861_adc_nids,
16177		.input_mux = &alc861_capture_source,
16178	},
16179	[ALC861_6ST_DIG] = {
16180		.mixers = { alc861_base_mixer },
16181		.init_verbs = { alc861_base_init_verbs },
16182		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16183		.dac_nids = alc861_dac_nids,
16184		.dig_out_nid = ALC861_DIGOUT_NID,
16185		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16186		.channel_mode = alc861_8ch_modes,
16187		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16188		.adc_nids = alc861_adc_nids,
16189		.input_mux = &alc861_capture_source,
16190	},
16191	[ALC660_3ST] = {
16192		.mixers = { alc861_3ST_mixer },
16193		.init_verbs = { alc861_threestack_init_verbs },
16194		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
16195		.dac_nids = alc660_dac_nids,
16196		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16197		.channel_mode = alc861_threestack_modes,
16198		.need_dac_fix = 1,
16199		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16200		.adc_nids = alc861_adc_nids,
16201		.input_mux = &alc861_capture_source,
16202	},
16203	[ALC861_UNIWILL_M31] = {
16204		.mixers = { alc861_uniwill_m31_mixer },
16205		.init_verbs = { alc861_uniwill_m31_init_verbs },
16206		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16207		.dac_nids = alc861_dac_nids,
16208		.dig_out_nid = ALC861_DIGOUT_NID,
16209		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16210		.channel_mode = alc861_uniwill_m31_modes,
16211		.need_dac_fix = 1,
16212		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16213		.adc_nids = alc861_adc_nids,
16214		.input_mux = &alc861_capture_source,
16215	},
16216	[ALC861_TOSHIBA] = {
16217		.mixers = { alc861_toshiba_mixer },
16218		.init_verbs = { alc861_base_init_verbs,
16219				alc861_toshiba_init_verbs },
16220		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16221		.dac_nids = alc861_dac_nids,
16222		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16223		.channel_mode = alc883_3ST_2ch_modes,
16224		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16225		.adc_nids = alc861_adc_nids,
16226		.input_mux = &alc861_capture_source,
16227		.unsol_event = alc861_toshiba_unsol_event,
16228		.init_hook = alc861_toshiba_automute,
16229	},
16230	[ALC861_ASUS] = {
16231		.mixers = { alc861_asus_mixer },
16232		.init_verbs = { alc861_asus_init_verbs },
16233		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16234		.dac_nids = alc861_dac_nids,
16235		.dig_out_nid = ALC861_DIGOUT_NID,
16236		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16237		.channel_mode = alc861_asus_modes,
16238		.need_dac_fix = 1,
16239		.hp_nid = 0x06,
16240		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16241		.adc_nids = alc861_adc_nids,
16242		.input_mux = &alc861_capture_source,
16243	},
16244	[ALC861_ASUS_LAPTOP] = {
16245		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16246		.init_verbs = { alc861_asus_init_verbs,
16247				alc861_asus_laptop_init_verbs },
16248		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16249		.dac_nids = alc861_dac_nids,
16250		.dig_out_nid = ALC861_DIGOUT_NID,
16251		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16252		.channel_mode = alc883_3ST_2ch_modes,
16253		.need_dac_fix = 1,
16254		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16255		.adc_nids = alc861_adc_nids,
16256		.input_mux = &alc861_capture_source,
16257	},
16258};
16259
16260/* Pin config fixes */
16261enum {
16262	PINFIX_FSC_AMILO_PI1505,
16263};
16264
16265static const struct alc_fixup alc861_fixups[] = {
16266	[PINFIX_FSC_AMILO_PI1505] = {
16267		.pins = (const struct alc_pincfg[]) {
16268			{ 0x0b, 0x0221101f }, /* HP */
16269			{ 0x0f, 0x90170310 }, /* speaker */
16270			{ }
16271		}
16272	},
16273};
16274
16275static struct snd_pci_quirk alc861_fixup_tbl[] = {
16276	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16277	{}
16278};
16279
16280static int patch_alc861(struct hda_codec *codec)
16281{
16282	struct alc_spec *spec;
16283	int board_config;
16284	int err;
16285
16286	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16287	if (spec == NULL)
16288		return -ENOMEM;
16289
16290	codec->spec = spec;
16291
16292        board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16293						  alc861_models,
16294						  alc861_cfg_tbl);
16295
16296	if (board_config < 0) {
16297		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16298		       codec->chip_name);
16299		board_config = ALC861_AUTO;
16300	}
16301
16302	if (board_config == ALC861_AUTO)
16303		alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
16304
16305	if (board_config == ALC861_AUTO) {
16306		/* automatic parse from the BIOS config */
16307		err = alc861_parse_auto_config(codec);
16308		if (err < 0) {
16309			alc_free(codec);
16310			return err;
16311		} else if (!err) {
16312			printk(KERN_INFO
16313			       "hda_codec: Cannot set up configuration "
16314			       "from BIOS.  Using base mode...\n");
16315		   board_config = ALC861_3ST_DIG;
16316		}
16317	}
16318
16319	err = snd_hda_attach_beep_device(codec, 0x23);
16320	if (err < 0) {
16321		alc_free(codec);
16322		return err;
16323	}
16324
16325	if (board_config != ALC861_AUTO)
16326		setup_preset(codec, &alc861_presets[board_config]);
16327
16328	spec->stream_analog_playback = &alc861_pcm_analog_playback;
16329	spec->stream_analog_capture = &alc861_pcm_analog_capture;
16330
16331	spec->stream_digital_playback = &alc861_pcm_digital_playback;
16332	spec->stream_digital_capture = &alc861_pcm_digital_capture;
16333
16334	if (!spec->cap_mixer)
16335		set_capture_mixer(codec);
16336	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16337
16338	spec->vmaster_nid = 0x03;
16339
16340	if (board_config == ALC861_AUTO)
16341		alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
16342
16343	codec->patch_ops = alc_patch_ops;
16344	if (board_config == ALC861_AUTO) {
16345		spec->init_hook = alc861_auto_init;
16346#ifdef CONFIG_SND_HDA_POWER_SAVE
16347		spec->power_hook = alc_power_eapd;
16348#endif
16349	}
16350#ifdef CONFIG_SND_HDA_POWER_SAVE
16351	if (!spec->loopback.amplist)
16352		spec->loopback.amplist = alc861_loopbacks;
16353#endif
16354
16355	return 0;
16356}
16357
16358/*
16359 * ALC861-VD support
16360 *
16361 * Based on ALC882
16362 *
16363 * In addition, an independent DAC
16364 */
16365#define ALC861VD_DIGOUT_NID	0x06
16366
16367static hda_nid_t alc861vd_dac_nids[4] = {
16368	/* front, surr, clfe, side surr */
16369	0x02, 0x03, 0x04, 0x05
16370};
16371
16372/* dac_nids for ALC660vd are in a different order - according to
16373 * Realtek's driver.
16374 * This should probably result in a different mixer for 6stack models
16375 * of ALC660vd codecs, but for now there is only 3stack mixer
16376 * - and it is the same as in 861vd.
16377 * adc_nids in ALC660vd are (is) the same as in 861vd
16378 */
16379static hda_nid_t alc660vd_dac_nids[3] = {
16380	/* front, rear, clfe, rear_surr */
16381	0x02, 0x04, 0x03
16382};
16383
16384static hda_nid_t alc861vd_adc_nids[1] = {
16385	/* ADC0 */
16386	0x09,
16387};
16388
16389static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16390
16391/* input MUX */
16392/* FIXME: should be a matrix-type input source selection */
16393static struct hda_input_mux alc861vd_capture_source = {
16394	.num_items = 4,
16395	.items = {
16396		{ "Mic", 0x0 },
16397		{ "Front Mic", 0x1 },
16398		{ "Line", 0x2 },
16399		{ "CD", 0x4 },
16400	},
16401};
16402
16403static struct hda_input_mux alc861vd_dallas_capture_source = {
16404	.num_items = 2,
16405	.items = {
16406		{ "Ext Mic", 0x0 },
16407		{ "Int Mic", 0x1 },
16408	},
16409};
16410
16411static struct hda_input_mux alc861vd_hp_capture_source = {
16412	.num_items = 2,
16413	.items = {
16414		{ "Front Mic", 0x0 },
16415		{ "ATAPI Mic", 0x1 },
16416	},
16417};
16418
16419/*
16420 * 2ch mode
16421 */
16422static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16423	{ 2, NULL }
16424};
16425
16426/*
16427 * 6ch mode
16428 */
16429static struct hda_verb alc861vd_6stack_ch6_init[] = {
16430	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16431	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16432	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16433	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16434	{ } /* end */
16435};
16436
16437/*
16438 * 8ch mode
16439 */
16440static struct hda_verb alc861vd_6stack_ch8_init[] = {
16441	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16442	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16443	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16444	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16445	{ } /* end */
16446};
16447
16448static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16449	{ 6, alc861vd_6stack_ch6_init },
16450	{ 8, alc861vd_6stack_ch8_init },
16451};
16452
16453static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16454	{
16455		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16456		.name = "Channel Mode",
16457		.info = alc_ch_mode_info,
16458		.get = alc_ch_mode_get,
16459		.put = alc_ch_mode_put,
16460	},
16461	{ } /* end */
16462};
16463
16464/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16465 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16466 */
16467static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16468	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16469	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16470
16471	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16472	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16473
16474	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16475				HDA_OUTPUT),
16476	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16477				HDA_OUTPUT),
16478	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16479	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16480
16481	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16482	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16483
16484	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16485
16486	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16487	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16488	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16489
16490	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16491	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16492	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16493
16494	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16495	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16496
16497	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16498	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16499
16500	{ } /* end */
16501};
16502
16503static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16504	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16505	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16506
16507	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16508
16509	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16510	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16511	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16512
16513	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16514	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16515	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16516
16517	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16518	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16519
16520	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16521	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16522
16523	{ } /* end */
16524};
16525
16526static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16527	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16528	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16529	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16530
16531	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16532
16533	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16534	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16535	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16536
16537	HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16538	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16539	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16540
16541	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16542	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16543
16544	{ } /* end */
16545};
16546
16547/* Pin assignment: Speaker=0x14, HP = 0x15,
16548 *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16549 */
16550static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16551	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16552	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16553	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16554	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16555	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16556	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16557	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16558	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16559	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16560	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16561	{ } /* end */
16562};
16563
16564/* Pin assignment: Speaker=0x14, Line-out = 0x15,
16565 *                 Front Mic=0x18, ATAPI Mic = 0x19,
16566 */
16567static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16568	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16569	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16570	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16571	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16572	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16573	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16574	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16575	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16576
16577	{ } /* end */
16578};
16579
16580/*
16581 * generic initialization of ADC, input mixers and output mixers
16582 */
16583static struct hda_verb alc861vd_volume_init_verbs[] = {
16584	/*
16585	 * Unmute ADC0 and set the default input to mic-in
16586	 */
16587	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16588	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16589
16590	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16591	 * the analog-loopback mixer widget
16592	 */
16593	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16594	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16595	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16596	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16597	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16598	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16599
16600	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16601	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16602	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16603	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16604	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16605
16606	/*
16607	 * Set up output mixers (0x02 - 0x05)
16608	 */
16609	/* set vol=0 to output mixers */
16610	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16611	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16612	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16613	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16614
16615	/* set up input amps for analog loopback */
16616	/* Amp Indices: DAC = 0, mixer = 1 */
16617	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16618	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16619	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16620	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16621	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16622	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16623	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16624	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16625
16626	{ }
16627};
16628
16629/*
16630 * 3-stack pin configuration:
16631 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16632 */
16633static struct hda_verb alc861vd_3stack_init_verbs[] = {
16634	/*
16635	 * Set pin mode and muting
16636	 */
16637	/* set front pin widgets 0x14 for output */
16638	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16639	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16640	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16641
16642	/* Mic (rear) pin: input vref at 80% */
16643	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16644	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16645	/* Front Mic pin: input vref at 80% */
16646	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16647	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16648	/* Line In pin: input */
16649	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16650	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16651	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16652	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16653	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16654	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16655	/* CD pin widget for input */
16656	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16657
16658	{ }
16659};
16660
16661/*
16662 * 6-stack pin configuration:
16663 */
16664static struct hda_verb alc861vd_6stack_init_verbs[] = {
16665	/*
16666	 * Set pin mode and muting
16667	 */
16668	/* set front pin widgets 0x14 for output */
16669	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16670	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16671	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16672
16673	/* Rear Pin: output 1 (0x0d) */
16674	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16675	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16676	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16677	/* CLFE Pin: output 2 (0x0e) */
16678	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16679	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16680	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16681	/* Side Pin: output 3 (0x0f) */
16682	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16683	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16684	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16685
16686	/* Mic (rear) pin: input vref at 80% */
16687	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16688	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16689	/* Front Mic pin: input vref at 80% */
16690	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16691	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16692	/* Line In pin: input */
16693	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16694	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16695	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16696	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16697	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16698	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16699	/* CD pin widget for input */
16700	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16701
16702	{ }
16703};
16704
16705static struct hda_verb alc861vd_eapd_verbs[] = {
16706	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16707	{ }
16708};
16709
16710static struct hda_verb alc660vd_eapd_verbs[] = {
16711	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16712	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16713	{ }
16714};
16715
16716static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16717	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16718	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16719	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16720	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16721	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16722	{}
16723};
16724
16725static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
16726{
16727	unsigned int present;
16728	unsigned char bits;
16729
16730	present = snd_hda_jack_detect(codec, 0x18);
16731	bits = present ? HDA_AMP_MUTE : 0;
16732
16733	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
16734				 HDA_AMP_MUTE, bits);
16735}
16736
16737static void alc861vd_lenovo_setup(struct hda_codec *codec)
16738{
16739	struct alc_spec *spec = codec->spec;
16740	spec->autocfg.hp_pins[0] = 0x1b;
16741	spec->autocfg.speaker_pins[0] = 0x14;
16742}
16743
16744static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16745{
16746	alc_automute_amp(codec);
16747	alc861vd_lenovo_mic_automute(codec);
16748}
16749
16750static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16751					unsigned int res)
16752{
16753	switch (res >> 26) {
16754	case ALC880_MIC_EVENT:
16755		alc861vd_lenovo_mic_automute(codec);
16756		break;
16757	default:
16758		alc_automute_amp_unsol_event(codec, res);
16759		break;
16760	}
16761}
16762
16763static struct hda_verb alc861vd_dallas_verbs[] = {
16764	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16765	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16766	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16767	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16768
16769	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16770	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16771	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16772	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16773	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16774	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16775	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16776	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16777
16778	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16779	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16780	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16781	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16782	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16783	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16784	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16785	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16786
16787	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16788	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16789	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16790	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16791	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16792	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16793	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16794	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16795
16796	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16797	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16798	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16799	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16800
16801	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16802	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16803	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16804
16805	{ } /* end */
16806};
16807
16808/* toggle speaker-output according to the hp-jack state */
16809static void alc861vd_dallas_setup(struct hda_codec *codec)
16810{
16811	struct alc_spec *spec = codec->spec;
16812
16813	spec->autocfg.hp_pins[0] = 0x15;
16814	spec->autocfg.speaker_pins[0] = 0x14;
16815}
16816
16817#ifdef CONFIG_SND_HDA_POWER_SAVE
16818#define alc861vd_loopbacks	alc880_loopbacks
16819#endif
16820
16821/* pcm configuration: identical with ALC880 */
16822#define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
16823#define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
16824#define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
16825#define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
16826
16827/*
16828 * configuration and preset
16829 */
16830static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16831	[ALC660VD_3ST]		= "3stack-660",
16832	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
16833	[ALC660VD_ASUS_V1S]	= "asus-v1s",
16834	[ALC861VD_3ST]		= "3stack",
16835	[ALC861VD_3ST_DIG]	= "3stack-digout",
16836	[ALC861VD_6ST_DIG]	= "6stack-digout",
16837	[ALC861VD_LENOVO]	= "lenovo",
16838	[ALC861VD_DALLAS]	= "dallas",
16839	[ALC861VD_HP]		= "hp",
16840	[ALC861VD_AUTO]		= "auto",
16841};
16842
16843static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16844	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16845	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16846	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16847	/*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16848	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16849	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16850	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16851	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16852	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16853	SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16854	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16855	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16856	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16857	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16858	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16859	{}
16860};
16861
16862static struct alc_config_preset alc861vd_presets[] = {
16863	[ALC660VD_3ST] = {
16864		.mixers = { alc861vd_3st_mixer },
16865		.init_verbs = { alc861vd_volume_init_verbs,
16866				 alc861vd_3stack_init_verbs },
16867		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16868		.dac_nids = alc660vd_dac_nids,
16869		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16870		.channel_mode = alc861vd_3stack_2ch_modes,
16871		.input_mux = &alc861vd_capture_source,
16872	},
16873	[ALC660VD_3ST_DIG] = {
16874		.mixers = { alc861vd_3st_mixer },
16875		.init_verbs = { alc861vd_volume_init_verbs,
16876				 alc861vd_3stack_init_verbs },
16877		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16878		.dac_nids = alc660vd_dac_nids,
16879		.dig_out_nid = ALC861VD_DIGOUT_NID,
16880		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16881		.channel_mode = alc861vd_3stack_2ch_modes,
16882		.input_mux = &alc861vd_capture_source,
16883	},
16884	[ALC861VD_3ST] = {
16885		.mixers = { alc861vd_3st_mixer },
16886		.init_verbs = { alc861vd_volume_init_verbs,
16887				 alc861vd_3stack_init_verbs },
16888		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16889		.dac_nids = alc861vd_dac_nids,
16890		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16891		.channel_mode = alc861vd_3stack_2ch_modes,
16892		.input_mux = &alc861vd_capture_source,
16893	},
16894	[ALC861VD_3ST_DIG] = {
16895		.mixers = { alc861vd_3st_mixer },
16896		.init_verbs = { alc861vd_volume_init_verbs,
16897		 		 alc861vd_3stack_init_verbs },
16898		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16899		.dac_nids = alc861vd_dac_nids,
16900		.dig_out_nid = ALC861VD_DIGOUT_NID,
16901		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16902		.channel_mode = alc861vd_3stack_2ch_modes,
16903		.input_mux = &alc861vd_capture_source,
16904	},
16905	[ALC861VD_6ST_DIG] = {
16906		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16907		.init_verbs = { alc861vd_volume_init_verbs,
16908				alc861vd_6stack_init_verbs },
16909		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16910		.dac_nids = alc861vd_dac_nids,
16911		.dig_out_nid = ALC861VD_DIGOUT_NID,
16912		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16913		.channel_mode = alc861vd_6stack_modes,
16914		.input_mux = &alc861vd_capture_source,
16915	},
16916	[ALC861VD_LENOVO] = {
16917		.mixers = { alc861vd_lenovo_mixer },
16918		.init_verbs = { alc861vd_volume_init_verbs,
16919				alc861vd_3stack_init_verbs,
16920				alc861vd_eapd_verbs,
16921				alc861vd_lenovo_unsol_verbs },
16922		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16923		.dac_nids = alc660vd_dac_nids,
16924		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16925		.channel_mode = alc861vd_3stack_2ch_modes,
16926		.input_mux = &alc861vd_capture_source,
16927		.unsol_event = alc861vd_lenovo_unsol_event,
16928		.setup = alc861vd_lenovo_setup,
16929		.init_hook = alc861vd_lenovo_init_hook,
16930	},
16931	[ALC861VD_DALLAS] = {
16932		.mixers = { alc861vd_dallas_mixer },
16933		.init_verbs = { alc861vd_dallas_verbs },
16934		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16935		.dac_nids = alc861vd_dac_nids,
16936		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16937		.channel_mode = alc861vd_3stack_2ch_modes,
16938		.input_mux = &alc861vd_dallas_capture_source,
16939		.unsol_event = alc_automute_amp_unsol_event,
16940		.setup = alc861vd_dallas_setup,
16941		.init_hook = alc_automute_amp,
16942	},
16943	[ALC861VD_HP] = {
16944		.mixers = { alc861vd_hp_mixer },
16945		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16946		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16947		.dac_nids = alc861vd_dac_nids,
16948		.dig_out_nid = ALC861VD_DIGOUT_NID,
16949		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16950		.channel_mode = alc861vd_3stack_2ch_modes,
16951		.input_mux = &alc861vd_hp_capture_source,
16952		.unsol_event = alc_automute_amp_unsol_event,
16953		.setup = alc861vd_dallas_setup,
16954		.init_hook = alc_automute_amp,
16955	},
16956	[ALC660VD_ASUS_V1S] = {
16957		.mixers = { alc861vd_lenovo_mixer },
16958		.init_verbs = { alc861vd_volume_init_verbs,
16959				alc861vd_3stack_init_verbs,
16960				alc861vd_eapd_verbs,
16961				alc861vd_lenovo_unsol_verbs },
16962		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16963		.dac_nids = alc660vd_dac_nids,
16964		.dig_out_nid = ALC861VD_DIGOUT_NID,
16965		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16966		.channel_mode = alc861vd_3stack_2ch_modes,
16967		.input_mux = &alc861vd_capture_source,
16968		.unsol_event = alc861vd_lenovo_unsol_event,
16969		.setup = alc861vd_lenovo_setup,
16970		.init_hook = alc861vd_lenovo_init_hook,
16971	},
16972};
16973
16974/*
16975 * BIOS auto configuration
16976 */
16977static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16978						const struct auto_pin_cfg *cfg)
16979{
16980	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
16981}
16982
16983
16984static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16985				hda_nid_t nid, int pin_type, int dac_idx)
16986{
16987	alc_set_pin_output(codec, nid, pin_type);
16988}
16989
16990static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16991{
16992	struct alc_spec *spec = codec->spec;
16993	int i;
16994
16995	for (i = 0; i <= HDA_SIDE; i++) {
16996		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16997		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16998		if (nid)
16999			alc861vd_auto_set_output_and_unmute(codec, nid,
17000							    pin_type, i);
17001	}
17002}
17003
17004
17005static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17006{
17007	struct alc_spec *spec = codec->spec;
17008	hda_nid_t pin;
17009
17010	pin = spec->autocfg.hp_pins[0];
17011	if (pin) /* connect to front and use dac 0 */
17012		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17013	pin = spec->autocfg.speaker_pins[0];
17014	if (pin)
17015		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17016}
17017
17018#define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
17019
17020static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17021{
17022	struct alc_spec *spec = codec->spec;
17023	struct auto_pin_cfg *cfg = &spec->autocfg;
17024	int i;
17025
17026	for (i = 0; i < cfg->num_inputs; i++) {
17027		hda_nid_t nid = cfg->inputs[i].pin;
17028		if (alc_is_input_pin(codec, nid)) {
17029			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17030			if (nid != ALC861VD_PIN_CD_NID &&
17031			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17032				snd_hda_codec_write(codec, nid, 0,
17033						AC_VERB_SET_AMP_GAIN_MUTE,
17034						AMP_OUT_MUTE);
17035		}
17036	}
17037}
17038
17039#define alc861vd_auto_init_input_src	alc882_auto_init_input_src
17040
17041#define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
17042#define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
17043
17044/* add playback controls from the parsed DAC table */
17045/* Based on ALC880 version. But ALC861VD has separate,
17046 * different NIDs for mute/unmute switch and volume control */
17047static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17048					     const struct auto_pin_cfg *cfg)
17049{
17050	static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
17051	hda_nid_t nid_v, nid_s;
17052	int i, err;
17053
17054	for (i = 0; i < cfg->line_outs; i++) {
17055		if (!spec->multiout.dac_nids[i])
17056			continue;
17057		nid_v = alc861vd_idx_to_mixer_vol(
17058				alc880_dac_to_idx(
17059					spec->multiout.dac_nids[i]));
17060		nid_s = alc861vd_idx_to_mixer_switch(
17061				alc880_dac_to_idx(
17062					spec->multiout.dac_nids[i]));
17063
17064		if (i == 2) {
17065			/* Center/LFE */
17066			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17067					      "Center",
17068					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17069							      HDA_OUTPUT));
17070			if (err < 0)
17071				return err;
17072			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17073					      "LFE",
17074					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17075							      HDA_OUTPUT));
17076			if (err < 0)
17077				return err;
17078			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17079					     "Center",
17080					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17081							      HDA_INPUT));
17082			if (err < 0)
17083				return err;
17084			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17085					     "LFE",
17086					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17087							      HDA_INPUT));
17088			if (err < 0)
17089				return err;
17090		} else {
17091			const char *pfx;
17092			if (cfg->line_outs == 1 &&
17093			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17094				if (!cfg->hp_pins)
17095					pfx = "Speaker";
17096				else
17097					pfx = "PCM";
17098			} else
17099				pfx = chname[i];
17100			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17101					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17102							      HDA_OUTPUT));
17103			if (err < 0)
17104				return err;
17105			if (cfg->line_outs == 1 &&
17106			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17107				pfx = "Speaker";
17108			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17109					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17110							      HDA_INPUT));
17111			if (err < 0)
17112				return err;
17113		}
17114	}
17115	return 0;
17116}
17117
17118/* add playback controls for speaker and HP outputs */
17119/* Based on ALC880 version. But ALC861VD has separate,
17120 * different NIDs for mute/unmute switch and volume control */
17121static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17122					hda_nid_t pin, const char *pfx)
17123{
17124	hda_nid_t nid_v, nid_s;
17125	int err;
17126
17127	if (!pin)
17128		return 0;
17129
17130	if (alc880_is_fixed_pin(pin)) {
17131		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17132		/* specify the DAC as the extra output */
17133		if (!spec->multiout.hp_nid)
17134			spec->multiout.hp_nid = nid_v;
17135		else
17136			spec->multiout.extra_out_nid[0] = nid_v;
17137		/* control HP volume/switch on the output mixer amp */
17138		nid_v = alc861vd_idx_to_mixer_vol(
17139				alc880_fixed_pin_idx(pin));
17140		nid_s = alc861vd_idx_to_mixer_switch(
17141				alc880_fixed_pin_idx(pin));
17142
17143		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17144				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17145		if (err < 0)
17146			return err;
17147		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17148				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17149		if (err < 0)
17150			return err;
17151	} else if (alc880_is_multi_pin(pin)) {
17152		/* set manual connection */
17153		/* we have only a switch on HP-out PIN */
17154		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17155				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17156		if (err < 0)
17157			return err;
17158	}
17159	return 0;
17160}
17161
17162/* parse the BIOS configuration and set up the alc_spec
17163 * return 1 if successful, 0 if the proper config is not found,
17164 * or a negative error code
17165 * Based on ALC880 version - had to change it to override
17166 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17167static int alc861vd_parse_auto_config(struct hda_codec *codec)
17168{
17169	struct alc_spec *spec = codec->spec;
17170	int err;
17171	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17172
17173	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17174					   alc861vd_ignore);
17175	if (err < 0)
17176		return err;
17177	if (!spec->autocfg.line_outs)
17178		return 0; /* can't find valid BIOS pin config */
17179
17180	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17181	if (err < 0)
17182		return err;
17183	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17184	if (err < 0)
17185		return err;
17186	err = alc861vd_auto_create_extra_out(spec,
17187					     spec->autocfg.speaker_pins[0],
17188					     "Speaker");
17189	if (err < 0)
17190		return err;
17191	err = alc861vd_auto_create_extra_out(spec,
17192					     spec->autocfg.hp_pins[0],
17193					     "Headphone");
17194	if (err < 0)
17195		return err;
17196	err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17197	if (err < 0)
17198		return err;
17199
17200	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17201
17202	alc_auto_parse_digital(codec);
17203
17204	if (spec->kctls.list)
17205		add_mixer(spec, spec->kctls.list);
17206
17207	add_verb(spec, alc861vd_volume_init_verbs);
17208
17209	spec->num_mux_defs = 1;
17210	spec->input_mux = &spec->private_imux[0];
17211
17212	err = alc_auto_add_mic_boost(codec);
17213	if (err < 0)
17214		return err;
17215
17216	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17217
17218	return 1;
17219}
17220
17221/* additional initialization for auto-configuration model */
17222static void alc861vd_auto_init(struct hda_codec *codec)
17223{
17224	struct alc_spec *spec = codec->spec;
17225	alc861vd_auto_init_multi_out(codec);
17226	alc861vd_auto_init_hp_out(codec);
17227	alc861vd_auto_init_analog_input(codec);
17228	alc861vd_auto_init_input_src(codec);
17229	alc_auto_init_digital(codec);
17230	if (spec->unsol_event)
17231		alc_inithook(codec);
17232}
17233
17234enum {
17235	ALC660VD_FIX_ASUS_GPIO1
17236};
17237
17238/* reset GPIO1 */
17239static const struct alc_fixup alc861vd_fixups[] = {
17240	[ALC660VD_FIX_ASUS_GPIO1] = {
17241		.verbs = (const struct hda_verb[]) {
17242			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17243			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17244			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17245			{ }
17246		}
17247	},
17248};
17249
17250static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17251	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17252	{}
17253};
17254
17255static int patch_alc861vd(struct hda_codec *codec)
17256{
17257	struct alc_spec *spec;
17258	int err, board_config;
17259
17260	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17261	if (spec == NULL)
17262		return -ENOMEM;
17263
17264	codec->spec = spec;
17265
17266	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17267						  alc861vd_models,
17268						  alc861vd_cfg_tbl);
17269
17270	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17271		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17272		       codec->chip_name);
17273		board_config = ALC861VD_AUTO;
17274	}
17275
17276	if (board_config == ALC861VD_AUTO)
17277		alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
17278
17279	if (board_config == ALC861VD_AUTO) {
17280		/* automatic parse from the BIOS config */
17281		err = alc861vd_parse_auto_config(codec);
17282		if (err < 0) {
17283			alc_free(codec);
17284			return err;
17285		} else if (!err) {
17286			printk(KERN_INFO
17287			       "hda_codec: Cannot set up configuration "
17288			       "from BIOS.  Using base mode...\n");
17289			board_config = ALC861VD_3ST;
17290		}
17291	}
17292
17293	err = snd_hda_attach_beep_device(codec, 0x23);
17294	if (err < 0) {
17295		alc_free(codec);
17296		return err;
17297	}
17298
17299	if (board_config != ALC861VD_AUTO)
17300		setup_preset(codec, &alc861vd_presets[board_config]);
17301
17302	if (codec->vendor_id == 0x10ec0660) {
17303		/* always turn on EAPD */
17304		add_verb(spec, alc660vd_eapd_verbs);
17305	}
17306
17307	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17308	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17309
17310	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17311	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17312
17313	if (!spec->adc_nids) {
17314		spec->adc_nids = alc861vd_adc_nids;
17315		spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17316	}
17317	if (!spec->capsrc_nids)
17318		spec->capsrc_nids = alc861vd_capsrc_nids;
17319
17320	set_capture_mixer(codec);
17321	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17322
17323	spec->vmaster_nid = 0x02;
17324
17325	if (board_config == ALC861VD_AUTO)
17326		alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
17327
17328	codec->patch_ops = alc_patch_ops;
17329
17330	if (board_config == ALC861VD_AUTO)
17331		spec->init_hook = alc861vd_auto_init;
17332#ifdef CONFIG_SND_HDA_POWER_SAVE
17333	if (!spec->loopback.amplist)
17334		spec->loopback.amplist = alc861vd_loopbacks;
17335#endif
17336
17337	return 0;
17338}
17339
17340/*
17341 * ALC662 support
17342 *
17343 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17344 * configuration.  Each pin widget can choose any input DACs and a mixer.
17345 * Each ADC is connected from a mixer of all inputs.  This makes possible
17346 * 6-channel independent captures.
17347 *
17348 * In addition, an independent DAC for the multi-playback (not used in this
17349 * driver yet).
17350 */
17351#define ALC662_DIGOUT_NID	0x06
17352#define ALC662_DIGIN_NID	0x0a
17353
17354static hda_nid_t alc662_dac_nids[4] = {
17355	/* front, rear, clfe, rear_surr */
17356	0x02, 0x03, 0x04
17357};
17358
17359static hda_nid_t alc272_dac_nids[2] = {
17360	0x02, 0x03
17361};
17362
17363static hda_nid_t alc662_adc_nids[2] = {
17364	/* ADC1-2 */
17365	0x09, 0x08
17366};
17367
17368static hda_nid_t alc272_adc_nids[1] = {
17369	/* ADC1-2 */
17370	0x08,
17371};
17372
17373static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17374static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17375
17376
17377/* input MUX */
17378/* FIXME: should be a matrix-type input source selection */
17379static struct hda_input_mux alc662_capture_source = {
17380	.num_items = 4,
17381	.items = {
17382		{ "Mic", 0x0 },
17383		{ "Front Mic", 0x1 },
17384		{ "Line", 0x2 },
17385		{ "CD", 0x4 },
17386	},
17387};
17388
17389static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17390	.num_items = 2,
17391	.items = {
17392		{ "Mic", 0x1 },
17393		{ "Line", 0x2 },
17394	},
17395};
17396
17397static struct hda_input_mux alc663_capture_source = {
17398	.num_items = 3,
17399	.items = {
17400		{ "Mic", 0x0 },
17401		{ "Front Mic", 0x1 },
17402		{ "Line", 0x2 },
17403	},
17404};
17405
17406#if 0 /* set to 1 for testing other input sources below */
17407static struct hda_input_mux alc272_nc10_capture_source = {
17408	.num_items = 16,
17409	.items = {
17410		{ "Autoselect Mic", 0x0 },
17411		{ "Internal Mic", 0x1 },
17412		{ "In-0x02", 0x2 },
17413		{ "In-0x03", 0x3 },
17414		{ "In-0x04", 0x4 },
17415		{ "In-0x05", 0x5 },
17416		{ "In-0x06", 0x6 },
17417		{ "In-0x07", 0x7 },
17418		{ "In-0x08", 0x8 },
17419		{ "In-0x09", 0x9 },
17420		{ "In-0x0a", 0x0a },
17421		{ "In-0x0b", 0x0b },
17422		{ "In-0x0c", 0x0c },
17423		{ "In-0x0d", 0x0d },
17424		{ "In-0x0e", 0x0e },
17425		{ "In-0x0f", 0x0f },
17426	},
17427};
17428#endif
17429
17430/*
17431 * 2ch mode
17432 */
17433static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17434	{ 2, NULL }
17435};
17436
17437/*
17438 * 2ch mode
17439 */
17440static struct hda_verb alc662_3ST_ch2_init[] = {
17441	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17442	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17443	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17444	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17445	{ } /* end */
17446};
17447
17448/*
17449 * 6ch mode
17450 */
17451static struct hda_verb alc662_3ST_ch6_init[] = {
17452	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17453	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17454	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17455	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17456	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17457	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17458	{ } /* end */
17459};
17460
17461static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17462	{ 2, alc662_3ST_ch2_init },
17463	{ 6, alc662_3ST_ch6_init },
17464};
17465
17466/*
17467 * 2ch mode
17468 */
17469static struct hda_verb alc662_sixstack_ch6_init[] = {
17470	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17471	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17472	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17473	{ } /* end */
17474};
17475
17476/*
17477 * 6ch mode
17478 */
17479static struct hda_verb alc662_sixstack_ch8_init[] = {
17480	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17481	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17482	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17483	{ } /* end */
17484};
17485
17486static struct hda_channel_mode alc662_5stack_modes[2] = {
17487	{ 2, alc662_sixstack_ch6_init },
17488	{ 6, alc662_sixstack_ch8_init },
17489};
17490
17491/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17492 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17493 */
17494
17495static struct snd_kcontrol_new alc662_base_mixer[] = {
17496	/* output mixer control */
17497	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17498	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17499	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17500	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17501	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17502	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17503	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17504	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17505	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17506
17507	/*Input mixer control */
17508	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17509	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17510	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17511	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17512	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17513	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17514	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17515	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17516	{ } /* end */
17517};
17518
17519static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17520	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17521	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17522	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17523	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17524	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17525	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17526	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17527	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17528	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17529	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17530	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17531	{ } /* end */
17532};
17533
17534static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17535	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17536	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17537	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17538	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17539	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17540	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17541	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17542	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17543	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17544	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17545	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17546	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17547	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17548	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17549	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17550	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17551	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17552	{ } /* end */
17553};
17554
17555static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17556	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17557	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17558	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17559	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17560	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17561	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17562	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17563	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17564	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17565	{ } /* end */
17566};
17567
17568static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17569	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17570	ALC262_HIPPO_MASTER_SWITCH,
17571
17572	HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
17573	HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17574	HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17575
17576	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17577	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17578	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17579	{ } /* end */
17580};
17581
17582static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17583	ALC262_HIPPO_MASTER_SWITCH,
17584	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17585	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17586	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17587	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17588	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17589	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17590	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17591	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17592	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17593	{ } /* end */
17594};
17595
17596static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17597	.ops = &snd_hda_bind_vol,
17598	.values = {
17599		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17600		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17601		0
17602	},
17603};
17604
17605static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17606	.ops = &snd_hda_bind_sw,
17607	.values = {
17608		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17609		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17610		0
17611	},
17612};
17613
17614static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17615	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17616	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17617	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17618	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17619	{ } /* end */
17620};
17621
17622static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17623	.ops = &snd_hda_bind_sw,
17624	.values = {
17625		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17626		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17627		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17628		0
17629	},
17630};
17631
17632static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17633	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17634	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17635	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17636	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17637	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17638	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17639
17640	{ } /* end */
17641};
17642
17643static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17644	.ops = &snd_hda_bind_sw,
17645	.values = {
17646		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17647		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17648		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17649		0
17650	},
17651};
17652
17653static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17654	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17655	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17656	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17657	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17658	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17659	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17660	{ } /* end */
17661};
17662
17663static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17664	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17665	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17666	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17667	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17668	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17669	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17670	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17671	{ } /* end */
17672};
17673
17674static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17675	.ops = &snd_hda_bind_vol,
17676	.values = {
17677		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17678		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17679		0
17680	},
17681};
17682
17683static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17684	.ops = &snd_hda_bind_sw,
17685	.values = {
17686		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17687		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17688		0
17689	},
17690};
17691
17692static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17693	HDA_BIND_VOL("Master Playback Volume",
17694				&alc663_asus_two_bind_master_vol),
17695	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17696	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17697	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17698	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17699	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17700	{ } /* end */
17701};
17702
17703static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17704	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17705	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17706	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17707	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17708	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17709	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17710	{ } /* end */
17711};
17712
17713static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17714	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17715	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17716	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17717	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17718	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17719
17720	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17721	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17722	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17723	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17724	{ } /* end */
17725};
17726
17727static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17728	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17729	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17730	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17731
17732	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17733	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17734	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17735	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17736	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17737	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17738	{ } /* end */
17739};
17740
17741static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17742	.ops = &snd_hda_bind_sw,
17743	.values = {
17744		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17745		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17746		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17747		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17748		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17749		0
17750	},
17751};
17752
17753static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17754	.ops = &snd_hda_bind_sw,
17755	.values = {
17756		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17757		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17758		0
17759	},
17760};
17761
17762static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17763	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17764	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17765	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17766	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17767	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17768	HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17769	HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17770	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17771	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17772	{ } /* end */
17773};
17774
17775static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17776	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17777	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17778	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17779	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17780	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17781	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17782	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17783	{ } /* end */
17784};
17785
17786
17787static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17788	{
17789		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17790		.name = "Channel Mode",
17791		.info = alc_ch_mode_info,
17792		.get = alc_ch_mode_get,
17793		.put = alc_ch_mode_put,
17794	},
17795	{ } /* end */
17796};
17797
17798static struct hda_verb alc662_init_verbs[] = {
17799	/* ADC: mute amp left and right */
17800	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17801	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17802
17803	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17804	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17805	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17806	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17807	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17808	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17809
17810	/* Front Pin: output 0 (0x0c) */
17811	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17812	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17813
17814	/* Rear Pin: output 1 (0x0d) */
17815	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17816	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17817
17818	/* CLFE Pin: output 2 (0x0e) */
17819	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17820	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17821
17822	/* Mic (rear) pin: input vref at 80% */
17823	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17824	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17825	/* Front Mic pin: input vref at 80% */
17826	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17827	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17828	/* Line In pin: input */
17829	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17830	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17831	/* Line-2 In: Headphone output (output 0 - 0x0c) */
17832	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17833	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17834	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17835	/* CD pin widget for input */
17836	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17837
17838	/* FIXME: use matrix-type input source selection */
17839	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17840	/* Input mixer */
17841	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17842	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17843
17844	/* always trun on EAPD */
17845	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17846	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17847
17848	{ }
17849};
17850
17851static struct hda_verb alc663_init_verbs[] = {
17852	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17853	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17854	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17855	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17856	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17857	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17858	{ }
17859};
17860
17861static struct hda_verb alc272_init_verbs[] = {
17862	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17863	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17864	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17865	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17866	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17867	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17868	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17869	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17870	{ }
17871};
17872
17873static struct hda_verb alc662_sue_init_verbs[] = {
17874	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17875	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17876	{}
17877};
17878
17879static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17880	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17881	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17882	{}
17883};
17884
17885/* Set Unsolicited Event*/
17886static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17887	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17888	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17889	{}
17890};
17891
17892static struct hda_verb alc663_m51va_init_verbs[] = {
17893	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17894	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17895	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17896	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17897	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17898	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17899	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17900	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17901	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17902	{}
17903};
17904
17905static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17906	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17907	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17908	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17909	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17910	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17911	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17912	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17913	{}
17914};
17915
17916static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17917	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17918	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17919	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17920	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17921	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17922	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17923	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17924	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17925	{}
17926};
17927
17928static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17929	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17930	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17931	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17932	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17933	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17934	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17935	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17936	{}
17937};
17938
17939static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17940	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17941	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17942	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17943	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
17944	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17945	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17946	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
17947	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17948	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17949	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17950	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17951	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17952	{}
17953};
17954
17955static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17956	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17957	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17958	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17959	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17960	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17961	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17962	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17963	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17964	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17965	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17966	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17967	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17968	{}
17969};
17970
17971static struct hda_verb alc663_g71v_init_verbs[] = {
17972	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17973	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17974	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17975
17976	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17977	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17978	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17979
17980	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17981	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17982	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17983	{}
17984};
17985
17986static struct hda_verb alc663_g50v_init_verbs[] = {
17987	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17988	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17989	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17990
17991	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17992	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17993	{}
17994};
17995
17996static struct hda_verb alc662_ecs_init_verbs[] = {
17997	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17998	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17999	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18000	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18001	{}
18002};
18003
18004static struct hda_verb alc272_dell_zm1_init_verbs[] = {
18005	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18006	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18007	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18008	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18009	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18010	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18011	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18012	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18013	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18014	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18015	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18016	{}
18017};
18018
18019static struct hda_verb alc272_dell_init_verbs[] = {
18020	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18021	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18022	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18023	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18024	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18025	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18026	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18027	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18028	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18029	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18030	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18031	{}
18032};
18033
18034static struct hda_verb alc663_mode7_init_verbs[] = {
18035	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18036	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18037	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18038	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18039	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18040	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18041	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18042	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18043	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18044	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18045	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18046	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18047	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18048	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18049	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18050	{}
18051};
18052
18053static struct hda_verb alc663_mode8_init_verbs[] = {
18054	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18055	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18056	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18057	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18058	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18059	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18060	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18061	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18062	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18063	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18064	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18065	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18066	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18067	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18068	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18069	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18070	{}
18071};
18072
18073static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18074	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18075	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18076	{ } /* end */
18077};
18078
18079static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18080	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18081	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18082	{ } /* end */
18083};
18084
18085static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18086{
18087	unsigned int present;
18088	unsigned char bits;
18089
18090	present = snd_hda_jack_detect(codec, 0x14);
18091	bits = present ? HDA_AMP_MUTE : 0;
18092
18093	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18094				 HDA_AMP_MUTE, bits);
18095}
18096
18097static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18098{
18099	unsigned int present;
18100	unsigned char bits;
18101
18102 	present = snd_hda_jack_detect(codec, 0x1b);
18103	bits = present ? HDA_AMP_MUTE : 0;
18104
18105	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18106				 HDA_AMP_MUTE, bits);
18107	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18108				 HDA_AMP_MUTE, bits);
18109}
18110
18111static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18112					   unsigned int res)
18113{
18114	if ((res >> 26) == ALC880_HP_EVENT)
18115		alc662_lenovo_101e_all_automute(codec);
18116	if ((res >> 26) == ALC880_FRONT_EVENT)
18117		alc662_lenovo_101e_ispeaker_automute(codec);
18118}
18119
18120/* unsolicited event for HP jack sensing */
18121static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18122				     unsigned int res)
18123{
18124	if ((res >> 26) == ALC880_MIC_EVENT)
18125		alc_mic_automute(codec);
18126	else
18127		alc262_hippo_unsol_event(codec, res);
18128}
18129
18130static void alc662_eeepc_setup(struct hda_codec *codec)
18131{
18132	struct alc_spec *spec = codec->spec;
18133
18134	alc262_hippo1_setup(codec);
18135	spec->ext_mic.pin = 0x18;
18136	spec->ext_mic.mux_idx = 0;
18137	spec->int_mic.pin = 0x19;
18138	spec->int_mic.mux_idx = 1;
18139	spec->auto_mic = 1;
18140}
18141
18142static void alc662_eeepc_inithook(struct hda_codec *codec)
18143{
18144	alc262_hippo_automute(codec);
18145	alc_mic_automute(codec);
18146}
18147
18148static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18149{
18150	struct alc_spec *spec = codec->spec;
18151
18152	spec->autocfg.hp_pins[0] = 0x14;
18153	spec->autocfg.speaker_pins[0] = 0x1b;
18154}
18155
18156#define alc662_eeepc_ep20_inithook	alc262_hippo_master_update
18157
18158static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18159{
18160	unsigned int present;
18161	unsigned char bits;
18162
18163	present = snd_hda_jack_detect(codec, 0x21);
18164	bits = present ? HDA_AMP_MUTE : 0;
18165	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18166				 HDA_AMP_MUTE, bits);
18167	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18168				 HDA_AMP_MUTE, bits);
18169}
18170
18171static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18172{
18173	unsigned int present;
18174	unsigned char bits;
18175
18176	present = snd_hda_jack_detect(codec, 0x21);
18177	bits = present ? HDA_AMP_MUTE : 0;
18178	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18179				 HDA_AMP_MUTE, bits);
18180	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18181				 HDA_AMP_MUTE, bits);
18182	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18183				 HDA_AMP_MUTE, bits);
18184	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18185				 HDA_AMP_MUTE, bits);
18186}
18187
18188static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18189{
18190	unsigned int present;
18191	unsigned char bits;
18192
18193	present = snd_hda_jack_detect(codec, 0x15);
18194	bits = present ? HDA_AMP_MUTE : 0;
18195	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18196				 HDA_AMP_MUTE, bits);
18197	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18198				 HDA_AMP_MUTE, bits);
18199	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18200				 HDA_AMP_MUTE, bits);
18201	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18202				 HDA_AMP_MUTE, bits);
18203}
18204
18205static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18206{
18207	unsigned int present;
18208	unsigned char bits;
18209
18210	present = snd_hda_jack_detect(codec, 0x1b);
18211	bits = present ? 0 : PIN_OUT;
18212	snd_hda_codec_write(codec, 0x14, 0,
18213			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18214}
18215
18216static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18217{
18218	unsigned int present1, present2;
18219
18220	present1 = snd_hda_jack_detect(codec, 0x21);
18221	present2 = snd_hda_jack_detect(codec, 0x15);
18222
18223	if (present1 || present2) {
18224		snd_hda_codec_write_cache(codec, 0x14, 0,
18225			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18226	} else {
18227		snd_hda_codec_write_cache(codec, 0x14, 0,
18228			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18229	}
18230}
18231
18232static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18233{
18234	unsigned int present1, present2;
18235
18236	present1 = snd_hda_jack_detect(codec, 0x1b);
18237	present2 = snd_hda_jack_detect(codec, 0x15);
18238
18239	if (present1 || present2) {
18240		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18241					 HDA_AMP_MUTE, HDA_AMP_MUTE);
18242		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18243					 HDA_AMP_MUTE, HDA_AMP_MUTE);
18244	} else {
18245		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18246					 HDA_AMP_MUTE, 0);
18247		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18248					 HDA_AMP_MUTE, 0);
18249	}
18250}
18251
18252static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18253{
18254	unsigned int present1, present2;
18255
18256	present1 = snd_hda_codec_read(codec, 0x1b, 0,
18257			AC_VERB_GET_PIN_SENSE, 0)
18258			& AC_PINSENSE_PRESENCE;
18259	present2 = snd_hda_codec_read(codec, 0x21, 0,
18260			AC_VERB_GET_PIN_SENSE, 0)
18261			& AC_PINSENSE_PRESENCE;
18262
18263	if (present1 || present2) {
18264		snd_hda_codec_write_cache(codec, 0x14, 0,
18265			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18266		snd_hda_codec_write_cache(codec, 0x17, 0,
18267			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18268	} else {
18269		snd_hda_codec_write_cache(codec, 0x14, 0,
18270			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18271		snd_hda_codec_write_cache(codec, 0x17, 0,
18272			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18273	}
18274}
18275
18276static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18277{
18278	unsigned int present1, present2;
18279
18280	present1 = snd_hda_codec_read(codec, 0x21, 0,
18281			AC_VERB_GET_PIN_SENSE, 0)
18282			& AC_PINSENSE_PRESENCE;
18283	present2 = snd_hda_codec_read(codec, 0x15, 0,
18284			AC_VERB_GET_PIN_SENSE, 0)
18285			& AC_PINSENSE_PRESENCE;
18286
18287	if (present1 || present2) {
18288		snd_hda_codec_write_cache(codec, 0x14, 0,
18289			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18290		snd_hda_codec_write_cache(codec, 0x17, 0,
18291			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18292	} else {
18293		snd_hda_codec_write_cache(codec, 0x14, 0,
18294			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18295		snd_hda_codec_write_cache(codec, 0x17, 0,
18296			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18297	}
18298}
18299
18300static void alc663_m51va_unsol_event(struct hda_codec *codec,
18301					   unsigned int res)
18302{
18303	switch (res >> 26) {
18304	case ALC880_HP_EVENT:
18305		alc663_m51va_speaker_automute(codec);
18306		break;
18307	case ALC880_MIC_EVENT:
18308		alc_mic_automute(codec);
18309		break;
18310	}
18311}
18312
18313static void alc663_m51va_setup(struct hda_codec *codec)
18314{
18315	struct alc_spec *spec = codec->spec;
18316	spec->ext_mic.pin = 0x18;
18317	spec->ext_mic.mux_idx = 0;
18318	spec->int_mic.pin = 0x12;
18319	spec->int_mic.mux_idx = 9;
18320	spec->auto_mic = 1;
18321}
18322
18323static void alc663_m51va_inithook(struct hda_codec *codec)
18324{
18325	alc663_m51va_speaker_automute(codec);
18326	alc_mic_automute(codec);
18327}
18328
18329/* ***************** Mode1 ******************************/
18330#define alc663_mode1_unsol_event	alc663_m51va_unsol_event
18331
18332static void alc663_mode1_setup(struct hda_codec *codec)
18333{
18334	struct alc_spec *spec = codec->spec;
18335	spec->ext_mic.pin = 0x18;
18336	spec->ext_mic.mux_idx = 0;
18337	spec->int_mic.pin = 0x19;
18338	spec->int_mic.mux_idx = 1;
18339	spec->auto_mic = 1;
18340}
18341
18342#define alc663_mode1_inithook		alc663_m51va_inithook
18343
18344/* ***************** Mode2 ******************************/
18345static void alc662_mode2_unsol_event(struct hda_codec *codec,
18346					   unsigned int res)
18347{
18348	switch (res >> 26) {
18349	case ALC880_HP_EVENT:
18350		alc662_f5z_speaker_automute(codec);
18351		break;
18352	case ALC880_MIC_EVENT:
18353		alc_mic_automute(codec);
18354		break;
18355	}
18356}
18357
18358#define alc662_mode2_setup	alc663_mode1_setup
18359
18360static void alc662_mode2_inithook(struct hda_codec *codec)
18361{
18362	alc662_f5z_speaker_automute(codec);
18363	alc_mic_automute(codec);
18364}
18365/* ***************** Mode3 ******************************/
18366static void alc663_mode3_unsol_event(struct hda_codec *codec,
18367					   unsigned int res)
18368{
18369	switch (res >> 26) {
18370	case ALC880_HP_EVENT:
18371		alc663_two_hp_m1_speaker_automute(codec);
18372		break;
18373	case ALC880_MIC_EVENT:
18374		alc_mic_automute(codec);
18375		break;
18376	}
18377}
18378
18379#define alc663_mode3_setup	alc663_mode1_setup
18380
18381static void alc663_mode3_inithook(struct hda_codec *codec)
18382{
18383	alc663_two_hp_m1_speaker_automute(codec);
18384	alc_mic_automute(codec);
18385}
18386/* ***************** Mode4 ******************************/
18387static void alc663_mode4_unsol_event(struct hda_codec *codec,
18388					   unsigned int res)
18389{
18390	switch (res >> 26) {
18391	case ALC880_HP_EVENT:
18392		alc663_21jd_two_speaker_automute(codec);
18393		break;
18394	case ALC880_MIC_EVENT:
18395		alc_mic_automute(codec);
18396		break;
18397	}
18398}
18399
18400#define alc663_mode4_setup	alc663_mode1_setup
18401
18402static void alc663_mode4_inithook(struct hda_codec *codec)
18403{
18404	alc663_21jd_two_speaker_automute(codec);
18405	alc_mic_automute(codec);
18406}
18407/* ***************** Mode5 ******************************/
18408static void alc663_mode5_unsol_event(struct hda_codec *codec,
18409					   unsigned int res)
18410{
18411	switch (res >> 26) {
18412	case ALC880_HP_EVENT:
18413		alc663_15jd_two_speaker_automute(codec);
18414		break;
18415	case ALC880_MIC_EVENT:
18416		alc_mic_automute(codec);
18417		break;
18418	}
18419}
18420
18421#define alc663_mode5_setup	alc663_mode1_setup
18422
18423static void alc663_mode5_inithook(struct hda_codec *codec)
18424{
18425	alc663_15jd_two_speaker_automute(codec);
18426	alc_mic_automute(codec);
18427}
18428/* ***************** Mode6 ******************************/
18429static void alc663_mode6_unsol_event(struct hda_codec *codec,
18430					   unsigned int res)
18431{
18432	switch (res >> 26) {
18433	case ALC880_HP_EVENT:
18434		alc663_two_hp_m2_speaker_automute(codec);
18435		break;
18436	case ALC880_MIC_EVENT:
18437		alc_mic_automute(codec);
18438		break;
18439	}
18440}
18441
18442#define alc663_mode6_setup	alc663_mode1_setup
18443
18444static void alc663_mode6_inithook(struct hda_codec *codec)
18445{
18446	alc663_two_hp_m2_speaker_automute(codec);
18447	alc_mic_automute(codec);
18448}
18449
18450/* ***************** Mode7 ******************************/
18451static void alc663_mode7_unsol_event(struct hda_codec *codec,
18452					   unsigned int res)
18453{
18454	switch (res >> 26) {
18455	case ALC880_HP_EVENT:
18456		alc663_two_hp_m7_speaker_automute(codec);
18457		break;
18458	case ALC880_MIC_EVENT:
18459		alc_mic_automute(codec);
18460		break;
18461	}
18462}
18463
18464#define alc663_mode7_setup	alc663_mode1_setup
18465
18466static void alc663_mode7_inithook(struct hda_codec *codec)
18467{
18468	alc663_two_hp_m7_speaker_automute(codec);
18469	alc_mic_automute(codec);
18470}
18471
18472/* ***************** Mode8 ******************************/
18473static void alc663_mode8_unsol_event(struct hda_codec *codec,
18474					   unsigned int res)
18475{
18476	switch (res >> 26) {
18477	case ALC880_HP_EVENT:
18478		alc663_two_hp_m8_speaker_automute(codec);
18479		break;
18480	case ALC880_MIC_EVENT:
18481		alc_mic_automute(codec);
18482		break;
18483	}
18484}
18485
18486#define alc663_mode8_setup	alc663_m51va_setup
18487
18488static void alc663_mode8_inithook(struct hda_codec *codec)
18489{
18490	alc663_two_hp_m8_speaker_automute(codec);
18491	alc_mic_automute(codec);
18492}
18493
18494static void alc663_g71v_hp_automute(struct hda_codec *codec)
18495{
18496	unsigned int present;
18497	unsigned char bits;
18498
18499	present = snd_hda_jack_detect(codec, 0x21);
18500	bits = present ? HDA_AMP_MUTE : 0;
18501	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18502				 HDA_AMP_MUTE, bits);
18503	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18504				 HDA_AMP_MUTE, bits);
18505}
18506
18507static void alc663_g71v_front_automute(struct hda_codec *codec)
18508{
18509	unsigned int present;
18510	unsigned char bits;
18511
18512	present = snd_hda_jack_detect(codec, 0x15);
18513	bits = present ? HDA_AMP_MUTE : 0;
18514	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18515				 HDA_AMP_MUTE, bits);
18516}
18517
18518static void alc663_g71v_unsol_event(struct hda_codec *codec,
18519					   unsigned int res)
18520{
18521	switch (res >> 26) {
18522	case ALC880_HP_EVENT:
18523		alc663_g71v_hp_automute(codec);
18524		break;
18525	case ALC880_FRONT_EVENT:
18526		alc663_g71v_front_automute(codec);
18527		break;
18528	case ALC880_MIC_EVENT:
18529		alc_mic_automute(codec);
18530		break;
18531	}
18532}
18533
18534#define alc663_g71v_setup	alc663_m51va_setup
18535
18536static void alc663_g71v_inithook(struct hda_codec *codec)
18537{
18538	alc663_g71v_front_automute(codec);
18539	alc663_g71v_hp_automute(codec);
18540	alc_mic_automute(codec);
18541}
18542
18543static void alc663_g50v_unsol_event(struct hda_codec *codec,
18544					   unsigned int res)
18545{
18546	switch (res >> 26) {
18547	case ALC880_HP_EVENT:
18548		alc663_m51va_speaker_automute(codec);
18549		break;
18550	case ALC880_MIC_EVENT:
18551		alc_mic_automute(codec);
18552		break;
18553	}
18554}
18555
18556#define alc663_g50v_setup	alc663_m51va_setup
18557
18558static void alc663_g50v_inithook(struct hda_codec *codec)
18559{
18560	alc663_m51va_speaker_automute(codec);
18561	alc_mic_automute(codec);
18562}
18563
18564static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18565	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18566	ALC262_HIPPO_MASTER_SWITCH,
18567
18568	HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
18569	HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18570	HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18571
18572	HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
18573	HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18574	HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18575	{ } /* end */
18576};
18577
18578static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18579	/* Master Playback automatically created from Speaker and Headphone */
18580	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18581	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18582	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18583	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18584
18585	HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18586	HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18587	HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
18588
18589	HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18590	HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18591	HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
18592	{ } /* end */
18593};
18594
18595#ifdef CONFIG_SND_HDA_POWER_SAVE
18596#define alc662_loopbacks	alc880_loopbacks
18597#endif
18598
18599
18600/* pcm configuration: identical with ALC880 */
18601#define alc662_pcm_analog_playback	alc880_pcm_analog_playback
18602#define alc662_pcm_analog_capture	alc880_pcm_analog_capture
18603#define alc662_pcm_digital_playback	alc880_pcm_digital_playback
18604#define alc662_pcm_digital_capture	alc880_pcm_digital_capture
18605
18606/*
18607 * configuration and preset
18608 */
18609static const char *alc662_models[ALC662_MODEL_LAST] = {
18610	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
18611	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
18612	[ALC662_3ST_6ch]	= "3stack-6ch",
18613	[ALC662_5ST_DIG]	= "6stack-dig",
18614	[ALC662_LENOVO_101E]	= "lenovo-101e",
18615	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18616	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18617	[ALC662_ECS] = "ecs",
18618	[ALC663_ASUS_M51VA] = "m51va",
18619	[ALC663_ASUS_G71V] = "g71v",
18620	[ALC663_ASUS_H13] = "h13",
18621	[ALC663_ASUS_G50V] = "g50v",
18622	[ALC663_ASUS_MODE1] = "asus-mode1",
18623	[ALC662_ASUS_MODE2] = "asus-mode2",
18624	[ALC663_ASUS_MODE3] = "asus-mode3",
18625	[ALC663_ASUS_MODE4] = "asus-mode4",
18626	[ALC663_ASUS_MODE5] = "asus-mode5",
18627	[ALC663_ASUS_MODE6] = "asus-mode6",
18628	[ALC663_ASUS_MODE7] = "asus-mode7",
18629	[ALC663_ASUS_MODE8] = "asus-mode8",
18630	[ALC272_DELL]		= "dell",
18631	[ALC272_DELL_ZM1]	= "dell-zm1",
18632	[ALC272_SAMSUNG_NC10]	= "samsung-nc10",
18633	[ALC662_AUTO]		= "auto",
18634};
18635
18636static struct snd_pci_quirk alc662_cfg_tbl[] = {
18637	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18638	SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18639	SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18640	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18641	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18642	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18643	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18644	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18645	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18646	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18647	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18648	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18649	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18650	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18651	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18652	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18653	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18654	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18655	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18656	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18657	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18658	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18659	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18660	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18661	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18662	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18663	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18664	SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18665	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18666	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18667	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18668	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18669	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18670	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18671	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18672	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18673	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18674	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18675	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18676	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18677	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18678	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18679	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18680	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18681	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18682	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18683	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18684	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18685	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18686	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18687	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18688	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18689	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18690	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18691	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18692	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18693	SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18694	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18695	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18696	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18697	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18698	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18699	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18700	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18701		      ALC662_3ST_6ch_DIG),
18702	SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18703	SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18704	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18705		      ALC662_3ST_6ch_DIG),
18706	SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18707	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18708	SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18709	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18710	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18711					ALC662_3ST_6ch_DIG),
18712	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18713			   ALC663_ASUS_H13),
18714	{}
18715};
18716
18717static struct alc_config_preset alc662_presets[] = {
18718	[ALC662_3ST_2ch_DIG] = {
18719		.mixers = { alc662_3ST_2ch_mixer },
18720		.init_verbs = { alc662_init_verbs },
18721		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18722		.dac_nids = alc662_dac_nids,
18723		.dig_out_nid = ALC662_DIGOUT_NID,
18724		.dig_in_nid = ALC662_DIGIN_NID,
18725		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18726		.channel_mode = alc662_3ST_2ch_modes,
18727		.input_mux = &alc662_capture_source,
18728	},
18729	[ALC662_3ST_6ch_DIG] = {
18730		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18731		.init_verbs = { alc662_init_verbs },
18732		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18733		.dac_nids = alc662_dac_nids,
18734		.dig_out_nid = ALC662_DIGOUT_NID,
18735		.dig_in_nid = ALC662_DIGIN_NID,
18736		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18737		.channel_mode = alc662_3ST_6ch_modes,
18738		.need_dac_fix = 1,
18739		.input_mux = &alc662_capture_source,
18740	},
18741	[ALC662_3ST_6ch] = {
18742		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18743		.init_verbs = { alc662_init_verbs },
18744		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18745		.dac_nids = alc662_dac_nids,
18746		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18747		.channel_mode = alc662_3ST_6ch_modes,
18748		.need_dac_fix = 1,
18749		.input_mux = &alc662_capture_source,
18750	},
18751	[ALC662_5ST_DIG] = {
18752		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
18753		.init_verbs = { alc662_init_verbs },
18754		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18755		.dac_nids = alc662_dac_nids,
18756		.dig_out_nid = ALC662_DIGOUT_NID,
18757		.dig_in_nid = ALC662_DIGIN_NID,
18758		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18759		.channel_mode = alc662_5stack_modes,
18760		.input_mux = &alc662_capture_source,
18761	},
18762	[ALC662_LENOVO_101E] = {
18763		.mixers = { alc662_lenovo_101e_mixer },
18764		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18765		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18766		.dac_nids = alc662_dac_nids,
18767		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18768		.channel_mode = alc662_3ST_2ch_modes,
18769		.input_mux = &alc662_lenovo_101e_capture_source,
18770		.unsol_event = alc662_lenovo_101e_unsol_event,
18771		.init_hook = alc662_lenovo_101e_all_automute,
18772	},
18773	[ALC662_ASUS_EEEPC_P701] = {
18774		.mixers = { alc662_eeepc_p701_mixer },
18775		.init_verbs = { alc662_init_verbs,
18776				alc662_eeepc_sue_init_verbs },
18777		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18778		.dac_nids = alc662_dac_nids,
18779		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18780		.channel_mode = alc662_3ST_2ch_modes,
18781		.unsol_event = alc662_eeepc_unsol_event,
18782		.setup = alc662_eeepc_setup,
18783		.init_hook = alc662_eeepc_inithook,
18784	},
18785	[ALC662_ASUS_EEEPC_EP20] = {
18786		.mixers = { alc662_eeepc_ep20_mixer,
18787			    alc662_chmode_mixer },
18788		.init_verbs = { alc662_init_verbs,
18789				alc662_eeepc_ep20_sue_init_verbs },
18790		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18791		.dac_nids = alc662_dac_nids,
18792		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18793		.channel_mode = alc662_3ST_6ch_modes,
18794		.input_mux = &alc662_lenovo_101e_capture_source,
18795		.unsol_event = alc662_eeepc_unsol_event,
18796		.setup = alc662_eeepc_ep20_setup,
18797		.init_hook = alc662_eeepc_ep20_inithook,
18798	},
18799	[ALC662_ECS] = {
18800		.mixers = { alc662_ecs_mixer },
18801		.init_verbs = { alc662_init_verbs,
18802				alc662_ecs_init_verbs },
18803		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18804		.dac_nids = alc662_dac_nids,
18805		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18806		.channel_mode = alc662_3ST_2ch_modes,
18807		.unsol_event = alc662_eeepc_unsol_event,
18808		.setup = alc662_eeepc_setup,
18809		.init_hook = alc662_eeepc_inithook,
18810	},
18811	[ALC663_ASUS_M51VA] = {
18812		.mixers = { alc663_m51va_mixer },
18813		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18814		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18815		.dac_nids = alc662_dac_nids,
18816		.dig_out_nid = ALC662_DIGOUT_NID,
18817		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18818		.channel_mode = alc662_3ST_2ch_modes,
18819		.unsol_event = alc663_m51va_unsol_event,
18820		.setup = alc663_m51va_setup,
18821		.init_hook = alc663_m51va_inithook,
18822	},
18823	[ALC663_ASUS_G71V] = {
18824		.mixers = { alc663_g71v_mixer },
18825		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18826		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
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_g71v_unsol_event,
18832		.setup = alc663_g71v_setup,
18833		.init_hook = alc663_g71v_inithook,
18834	},
18835	[ALC663_ASUS_H13] = {
18836		.mixers = { alc663_m51va_mixer },
18837		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18838		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18839		.dac_nids = alc662_dac_nids,
18840		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18841		.channel_mode = alc662_3ST_2ch_modes,
18842		.unsol_event = alc663_m51va_unsol_event,
18843		.init_hook = alc663_m51va_inithook,
18844	},
18845	[ALC663_ASUS_G50V] = {
18846		.mixers = { alc663_g50v_mixer },
18847		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18848		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18849		.dac_nids = alc662_dac_nids,
18850		.dig_out_nid = ALC662_DIGOUT_NID,
18851		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18852		.channel_mode = alc662_3ST_6ch_modes,
18853		.input_mux = &alc663_capture_source,
18854		.unsol_event = alc663_g50v_unsol_event,
18855		.setup = alc663_g50v_setup,
18856		.init_hook = alc663_g50v_inithook,
18857	},
18858	[ALC663_ASUS_MODE1] = {
18859		.mixers = { alc663_m51va_mixer },
18860		.cap_mixer = alc662_auto_capture_mixer,
18861		.init_verbs = { alc662_init_verbs,
18862				alc663_21jd_amic_init_verbs },
18863		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18864		.hp_nid = 0x03,
18865		.dac_nids = alc662_dac_nids,
18866		.dig_out_nid = ALC662_DIGOUT_NID,
18867		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18868		.channel_mode = alc662_3ST_2ch_modes,
18869		.unsol_event = alc663_mode1_unsol_event,
18870		.setup = alc663_mode1_setup,
18871		.init_hook = alc663_mode1_inithook,
18872	},
18873	[ALC662_ASUS_MODE2] = {
18874		.mixers = { alc662_1bjd_mixer },
18875		.cap_mixer = alc662_auto_capture_mixer,
18876		.init_verbs = { alc662_init_verbs,
18877				alc662_1bjd_amic_init_verbs },
18878		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18879		.dac_nids = alc662_dac_nids,
18880		.dig_out_nid = ALC662_DIGOUT_NID,
18881		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18882		.channel_mode = alc662_3ST_2ch_modes,
18883		.unsol_event = alc662_mode2_unsol_event,
18884		.setup = alc662_mode2_setup,
18885		.init_hook = alc662_mode2_inithook,
18886	},
18887	[ALC663_ASUS_MODE3] = {
18888		.mixers = { alc663_two_hp_m1_mixer },
18889		.cap_mixer = alc662_auto_capture_mixer,
18890		.init_verbs = { alc662_init_verbs,
18891				alc663_two_hp_amic_m1_init_verbs },
18892		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18893		.hp_nid = 0x03,
18894		.dac_nids = alc662_dac_nids,
18895		.dig_out_nid = ALC662_DIGOUT_NID,
18896		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18897		.channel_mode = alc662_3ST_2ch_modes,
18898		.unsol_event = alc663_mode3_unsol_event,
18899		.setup = alc663_mode3_setup,
18900		.init_hook = alc663_mode3_inithook,
18901	},
18902	[ALC663_ASUS_MODE4] = {
18903		.mixers = { alc663_asus_21jd_clfe_mixer },
18904		.cap_mixer = alc662_auto_capture_mixer,
18905		.init_verbs = { alc662_init_verbs,
18906				alc663_21jd_amic_init_verbs},
18907		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18908		.hp_nid = 0x03,
18909		.dac_nids = alc662_dac_nids,
18910		.dig_out_nid = ALC662_DIGOUT_NID,
18911		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18912		.channel_mode = alc662_3ST_2ch_modes,
18913		.unsol_event = alc663_mode4_unsol_event,
18914		.setup = alc663_mode4_setup,
18915		.init_hook = alc663_mode4_inithook,
18916	},
18917	[ALC663_ASUS_MODE5] = {
18918		.mixers = { alc663_asus_15jd_clfe_mixer },
18919		.cap_mixer = alc662_auto_capture_mixer,
18920		.init_verbs = { alc662_init_verbs,
18921				alc663_15jd_amic_init_verbs },
18922		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18923		.hp_nid = 0x03,
18924		.dac_nids = alc662_dac_nids,
18925		.dig_out_nid = ALC662_DIGOUT_NID,
18926		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18927		.channel_mode = alc662_3ST_2ch_modes,
18928		.unsol_event = alc663_mode5_unsol_event,
18929		.setup = alc663_mode5_setup,
18930		.init_hook = alc663_mode5_inithook,
18931	},
18932	[ALC663_ASUS_MODE6] = {
18933		.mixers = { alc663_two_hp_m2_mixer },
18934		.cap_mixer = alc662_auto_capture_mixer,
18935		.init_verbs = { alc662_init_verbs,
18936				alc663_two_hp_amic_m2_init_verbs },
18937		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18938		.hp_nid = 0x03,
18939		.dac_nids = alc662_dac_nids,
18940		.dig_out_nid = ALC662_DIGOUT_NID,
18941		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18942		.channel_mode = alc662_3ST_2ch_modes,
18943		.unsol_event = alc663_mode6_unsol_event,
18944		.setup = alc663_mode6_setup,
18945		.init_hook = alc663_mode6_inithook,
18946	},
18947	[ALC663_ASUS_MODE7] = {
18948		.mixers = { alc663_mode7_mixer },
18949		.cap_mixer = alc662_auto_capture_mixer,
18950		.init_verbs = { alc662_init_verbs,
18951				alc663_mode7_init_verbs },
18952		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18953		.hp_nid = 0x03,
18954		.dac_nids = alc662_dac_nids,
18955		.dig_out_nid = ALC662_DIGOUT_NID,
18956		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18957		.channel_mode = alc662_3ST_2ch_modes,
18958		.unsol_event = alc663_mode7_unsol_event,
18959		.setup = alc663_mode7_setup,
18960		.init_hook = alc663_mode7_inithook,
18961	},
18962	[ALC663_ASUS_MODE8] = {
18963		.mixers = { alc663_mode8_mixer },
18964		.cap_mixer = alc662_auto_capture_mixer,
18965		.init_verbs = { alc662_init_verbs,
18966				alc663_mode8_init_verbs },
18967		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18968		.hp_nid = 0x03,
18969		.dac_nids = alc662_dac_nids,
18970		.dig_out_nid = ALC662_DIGOUT_NID,
18971		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18972		.channel_mode = alc662_3ST_2ch_modes,
18973		.unsol_event = alc663_mode8_unsol_event,
18974		.setup = alc663_mode8_setup,
18975		.init_hook = alc663_mode8_inithook,
18976	},
18977	[ALC272_DELL] = {
18978		.mixers = { alc663_m51va_mixer },
18979		.cap_mixer = alc272_auto_capture_mixer,
18980		.init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18981		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18982		.dac_nids = alc662_dac_nids,
18983		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18984		.adc_nids = alc272_adc_nids,
18985		.num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18986		.capsrc_nids = alc272_capsrc_nids,
18987		.channel_mode = alc662_3ST_2ch_modes,
18988		.unsol_event = alc663_m51va_unsol_event,
18989		.setup = alc663_m51va_setup,
18990		.init_hook = alc663_m51va_inithook,
18991	},
18992	[ALC272_DELL_ZM1] = {
18993		.mixers = { alc663_m51va_mixer },
18994		.cap_mixer = alc662_auto_capture_mixer,
18995		.init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18996		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
18997		.dac_nids = alc662_dac_nids,
18998		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18999		.adc_nids = alc662_adc_nids,
19000		.num_adc_nids = 1,
19001		.capsrc_nids = alc662_capsrc_nids,
19002		.channel_mode = alc662_3ST_2ch_modes,
19003		.unsol_event = alc663_m51va_unsol_event,
19004		.setup = alc663_m51va_setup,
19005		.init_hook = alc663_m51va_inithook,
19006	},
19007	[ALC272_SAMSUNG_NC10] = {
19008		.mixers = { alc272_nc10_mixer },
19009		.init_verbs = { alc662_init_verbs,
19010				alc663_21jd_amic_init_verbs },
19011		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
19012		.dac_nids = alc272_dac_nids,
19013		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19014		.channel_mode = alc662_3ST_2ch_modes,
19015		/*.input_mux = &alc272_nc10_capture_source,*/
19016		.unsol_event = alc663_mode4_unsol_event,
19017		.setup = alc663_mode4_setup,
19018		.init_hook = alc663_mode4_inithook,
19019	},
19020};
19021
19022
19023/*
19024 * BIOS auto configuration
19025 */
19026
19027/* convert from MIX nid to DAC */
19028static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
19029{
19030	if (nid == 0x0f)
19031		return 0x02;
19032	else if (nid >= 0x0c && nid <= 0x0e)
19033		return nid - 0x0c + 0x02;
19034	else if (nid == 0x26) /* ALC887-VD has this DAC too */
19035		return 0x25;
19036	else
19037		return 0;
19038}
19039
19040/* get MIX nid connected to the given pin targeted to DAC */
19041static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19042				   hda_nid_t dac)
19043{
19044	hda_nid_t mix[5];
19045	int i, num;
19046
19047	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19048	for (i = 0; i < num; i++) {
19049		if (alc662_mix_to_dac(mix[i]) == dac)
19050			return mix[i];
19051	}
19052	return 0;
19053}
19054
19055/* look for an empty DAC slot */
19056static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19057{
19058	struct alc_spec *spec = codec->spec;
19059	hda_nid_t srcs[5];
19060	int i, j, num;
19061
19062	num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19063	if (num < 0)
19064		return 0;
19065	for (i = 0; i < num; i++) {
19066		hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19067		if (!nid)
19068			continue;
19069		for (j = 0; j < spec->multiout.num_dacs; j++)
19070			if (spec->multiout.dac_nids[j] == nid)
19071				break;
19072		if (j >= spec->multiout.num_dacs)
19073			return nid;
19074	}
19075	return 0;
19076}
19077
19078/* fill in the dac_nids table from the parsed pin configuration */
19079static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19080				     const struct auto_pin_cfg *cfg)
19081{
19082	struct alc_spec *spec = codec->spec;
19083	int i;
19084	hda_nid_t dac;
19085
19086	spec->multiout.dac_nids = spec->private_dac_nids;
19087	for (i = 0; i < cfg->line_outs; i++) {
19088		dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19089		if (!dac)
19090			continue;
19091		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19092	}
19093	return 0;
19094}
19095
19096static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19097			      hda_nid_t nid, unsigned int chs)
19098{
19099	return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
19100			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19101}
19102
19103static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19104			     hda_nid_t nid, unsigned int chs)
19105{
19106	return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19107			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19108}
19109
19110#define alc662_add_stereo_vol(spec, pfx, nid) \
19111	alc662_add_vol_ctl(spec, pfx, nid, 3)
19112#define alc662_add_stereo_sw(spec, pfx, nid) \
19113	alc662_add_sw_ctl(spec, pfx, nid, 3)
19114
19115/* add playback controls from the parsed DAC table */
19116static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19117					     const struct auto_pin_cfg *cfg)
19118{
19119	struct alc_spec *spec = codec->spec;
19120	static const char *chname[4] = {
19121		"Front", "Surround", NULL /*CLFE*/, "Side"
19122	};
19123	hda_nid_t nid, mix;
19124	int i, err;
19125
19126	for (i = 0; i < cfg->line_outs; i++) {
19127		nid = spec->multiout.dac_nids[i];
19128		if (!nid)
19129			continue;
19130		mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19131		if (!mix)
19132			continue;
19133		if (i == 2) {
19134			/* Center/LFE */
19135			err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19136			if (err < 0)
19137				return err;
19138			err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19139			if (err < 0)
19140				return err;
19141			err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19142			if (err < 0)
19143				return err;
19144			err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19145			if (err < 0)
19146				return err;
19147		} else {
19148			const char *pfx;
19149			if (cfg->line_outs == 1 &&
19150			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
19151				if (cfg->hp_outs)
19152					pfx = "Speaker";
19153				else
19154					pfx = "PCM";
19155			} else
19156				pfx = chname[i];
19157			err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19158			if (err < 0)
19159				return err;
19160			if (cfg->line_outs == 1 &&
19161			    cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19162				pfx = "Speaker";
19163			err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19164			if (err < 0)
19165				return err;
19166		}
19167	}
19168	return 0;
19169}
19170
19171/* add playback controls for speaker and HP outputs */
19172/* return DAC nid if any new DAC is assigned */
19173static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19174					const char *pfx)
19175{
19176	struct alc_spec *spec = codec->spec;
19177	hda_nid_t nid, mix;
19178	int err;
19179
19180	if (!pin)
19181		return 0;
19182	nid = alc662_look_for_dac(codec, pin);
19183	if (!nid) {
19184		/* the corresponding DAC is already occupied */
19185		if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19186			return 0; /* no way */
19187		/* create a switch only */
19188		return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19189				   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19190	}
19191
19192	mix = alc662_dac_to_mix(codec, pin, nid);
19193	if (!mix)
19194		return 0;
19195	err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19196	if (err < 0)
19197		return err;
19198	err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19199	if (err < 0)
19200		return err;
19201	return nid;
19202}
19203
19204/* create playback/capture controls for input pins */
19205#define alc662_auto_create_input_ctls \
19206	alc882_auto_create_input_ctls
19207
19208static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19209					      hda_nid_t nid, int pin_type,
19210					      hda_nid_t dac)
19211{
19212	int i, num;
19213	hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19214
19215	alc_set_pin_output(codec, nid, pin_type);
19216	/* need the manual connection? */
19217	num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19218	if (num <= 1)
19219		return;
19220	for (i = 0; i < num; i++) {
19221		if (alc662_mix_to_dac(srcs[i]) != dac)
19222			continue;
19223		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19224		return;
19225	}
19226}
19227
19228static void alc662_auto_init_multi_out(struct hda_codec *codec)
19229{
19230	struct alc_spec *spec = codec->spec;
19231	int pin_type = get_pin_type(spec->autocfg.line_out_type);
19232	int i;
19233
19234	for (i = 0; i <= HDA_SIDE; i++) {
19235		hda_nid_t nid = spec->autocfg.line_out_pins[i];
19236		if (nid)
19237			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19238					spec->multiout.dac_nids[i]);
19239	}
19240}
19241
19242static void alc662_auto_init_hp_out(struct hda_codec *codec)
19243{
19244	struct alc_spec *spec = codec->spec;
19245	hda_nid_t pin;
19246
19247	pin = spec->autocfg.hp_pins[0];
19248	if (pin)
19249		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19250						  spec->multiout.hp_nid);
19251	pin = spec->autocfg.speaker_pins[0];
19252	if (pin)
19253		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19254					spec->multiout.extra_out_nid[0]);
19255}
19256
19257#define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
19258
19259static void alc662_auto_init_analog_input(struct hda_codec *codec)
19260{
19261	struct alc_spec *spec = codec->spec;
19262	struct auto_pin_cfg *cfg = &spec->autocfg;
19263	int i;
19264
19265	for (i = 0; i < cfg->num_inputs; i++) {
19266		hda_nid_t nid = cfg->inputs[i].pin;
19267		if (alc_is_input_pin(codec, nid)) {
19268			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19269			if (nid != ALC662_PIN_CD_NID &&
19270			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19271				snd_hda_codec_write(codec, nid, 0,
19272						    AC_VERB_SET_AMP_GAIN_MUTE,
19273						    AMP_OUT_MUTE);
19274		}
19275	}
19276}
19277
19278#define alc662_auto_init_input_src	alc882_auto_init_input_src
19279
19280static int alc662_parse_auto_config(struct hda_codec *codec)
19281{
19282	struct alc_spec *spec = codec->spec;
19283	int err;
19284	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19285
19286	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19287					   alc662_ignore);
19288	if (err < 0)
19289		return err;
19290	if (!spec->autocfg.line_outs)
19291		return 0; /* can't find valid BIOS pin config */
19292
19293	err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19294	if (err < 0)
19295		return err;
19296	err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19297	if (err < 0)
19298		return err;
19299	err = alc662_auto_create_extra_out(codec,
19300					   spec->autocfg.speaker_pins[0],
19301					   "Speaker");
19302	if (err < 0)
19303		return err;
19304	if (err)
19305		spec->multiout.extra_out_nid[0] = err;
19306	err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19307					   "Headphone");
19308	if (err < 0)
19309		return err;
19310	if (err)
19311		spec->multiout.hp_nid = err;
19312	err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19313	if (err < 0)
19314		return err;
19315
19316	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19317
19318	alc_auto_parse_digital(codec);
19319
19320	if (spec->kctls.list)
19321		add_mixer(spec, spec->kctls.list);
19322
19323	spec->num_mux_defs = 1;
19324	spec->input_mux = &spec->private_imux[0];
19325
19326	add_verb(spec, alc662_init_verbs);
19327	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19328	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19329		add_verb(spec, alc663_init_verbs);
19330
19331	if (codec->vendor_id == 0x10ec0272)
19332		add_verb(spec, alc272_init_verbs);
19333
19334	err = alc_auto_add_mic_boost(codec);
19335	if (err < 0)
19336		return err;
19337
19338	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19339	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19340	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19341	else
19342	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19343
19344	return 1;
19345}
19346
19347/* additional initialization for auto-configuration model */
19348static void alc662_auto_init(struct hda_codec *codec)
19349{
19350	struct alc_spec *spec = codec->spec;
19351	alc662_auto_init_multi_out(codec);
19352	alc662_auto_init_hp_out(codec);
19353	alc662_auto_init_analog_input(codec);
19354	alc662_auto_init_input_src(codec);
19355	alc_auto_init_digital(codec);
19356	if (spec->unsol_event)
19357		alc_inithook(codec);
19358}
19359
19360enum {
19361	ALC662_FIXUP_ASPIRE,
19362	ALC662_FIXUP_IDEAPAD,
19363};
19364
19365static const struct alc_fixup alc662_fixups[] = {
19366	[ALC662_FIXUP_ASPIRE] = {
19367		.pins = (const struct alc_pincfg[]) {
19368			{ 0x15, 0x99130112 }, /* subwoofer */
19369			{ }
19370		}
19371	},
19372	[ALC662_FIXUP_IDEAPAD] = {
19373		.pins = (const struct alc_pincfg[]) {
19374			{ 0x17, 0x99130112 }, /* subwoofer */
19375			{ }
19376		}
19377	},
19378};
19379
19380static struct snd_pci_quirk alc662_fixup_tbl[] = {
19381	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19382	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19383	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19384	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19385	{}
19386};
19387
19388
19389
19390static int patch_alc662(struct hda_codec *codec)
19391{
19392	struct alc_spec *spec;
19393	int err, board_config;
19394	int coef;
19395
19396	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19397	if (!spec)
19398		return -ENOMEM;
19399
19400	codec->spec = spec;
19401
19402	alc_auto_parse_customize_define(codec);
19403
19404	alc_fix_pll_init(codec, 0x20, 0x04, 15);
19405
19406	coef = alc_read_coef_idx(codec, 0);
19407	if (coef == 0x8020 || coef == 0x8011)
19408		alc_codec_rename(codec, "ALC661");
19409	else if (coef & (1 << 14) &&
19410		codec->bus->pci->subsystem_vendor == 0x1025 &&
19411		spec->cdefine.platform_type == 1)
19412		alc_codec_rename(codec, "ALC272X");
19413	else if (coef == 0x4011)
19414		alc_codec_rename(codec, "ALC656");
19415
19416	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19417						  alc662_models,
19418			  	                  alc662_cfg_tbl);
19419	if (board_config < 0) {
19420		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19421		       codec->chip_name);
19422		board_config = ALC662_AUTO;
19423	}
19424
19425	if (board_config == ALC662_AUTO) {
19426		alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1);
19427		/* automatic parse from the BIOS config */
19428		err = alc662_parse_auto_config(codec);
19429		if (err < 0) {
19430			alc_free(codec);
19431			return err;
19432		} else if (!err) {
19433			printk(KERN_INFO
19434			       "hda_codec: Cannot set up configuration "
19435			       "from BIOS.  Using base mode...\n");
19436			board_config = ALC662_3ST_2ch_DIG;
19437		}
19438	}
19439
19440	if (has_cdefine_beep(codec)) {
19441		err = snd_hda_attach_beep_device(codec, 0x1);
19442		if (err < 0) {
19443			alc_free(codec);
19444			return err;
19445		}
19446	}
19447
19448	if (board_config != ALC662_AUTO)
19449		setup_preset(codec, &alc662_presets[board_config]);
19450
19451	spec->stream_analog_playback = &alc662_pcm_analog_playback;
19452	spec->stream_analog_capture = &alc662_pcm_analog_capture;
19453
19454	spec->stream_digital_playback = &alc662_pcm_digital_playback;
19455	spec->stream_digital_capture = &alc662_pcm_digital_capture;
19456
19457	if (!spec->adc_nids) {
19458		spec->adc_nids = alc662_adc_nids;
19459		spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19460	}
19461	if (!spec->capsrc_nids)
19462		spec->capsrc_nids = alc662_capsrc_nids;
19463
19464	if (!spec->cap_mixer)
19465		set_capture_mixer(codec);
19466
19467	if (has_cdefine_beep(codec)) {
19468		switch (codec->vendor_id) {
19469		case 0x10ec0662:
19470			set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19471			break;
19472		case 0x10ec0272:
19473		case 0x10ec0663:
19474		case 0x10ec0665:
19475			set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19476			break;
19477		case 0x10ec0273:
19478			set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19479			break;
19480		}
19481	}
19482	spec->vmaster_nid = 0x02;
19483
19484	codec->patch_ops = alc_patch_ops;
19485	if (board_config == ALC662_AUTO) {
19486		spec->init_hook = alc662_auto_init;
19487		alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 0);
19488	}
19489
19490	alc_init_jacks(codec);
19491
19492#ifdef CONFIG_SND_HDA_POWER_SAVE
19493	if (!spec->loopback.amplist)
19494		spec->loopback.amplist = alc662_loopbacks;
19495#endif
19496
19497	return 0;
19498}
19499
19500static int patch_alc888(struct hda_codec *codec)
19501{
19502	if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19503		kfree(codec->chip_name);
19504		if (codec->vendor_id == 0x10ec0887)
19505			codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19506		else
19507			codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19508		if (!codec->chip_name) {
19509			alc_free(codec);
19510			return -ENOMEM;
19511		}
19512		return patch_alc662(codec);
19513	}
19514	return patch_alc882(codec);
19515}
19516
19517/*
19518 * ALC680 support
19519 */
19520#define ALC680_DIGIN_NID	ALC880_DIGIN_NID
19521#define ALC680_DIGOUT_NID	ALC880_DIGOUT_NID
19522#define alc680_modes		alc260_modes
19523
19524static hda_nid_t alc680_dac_nids[3] = {
19525	/* Lout1, Lout2, hp */
19526	0x02, 0x03, 0x04
19527};
19528
19529static hda_nid_t alc680_adc_nids[3] = {
19530	/* ADC0-2 */
19531	/* DMIC, MIC, Line-in*/
19532	0x07, 0x08, 0x09
19533};
19534
19535/*
19536 * Analog capture ADC cgange
19537 */
19538static void alc680_rec_autoswitch(struct hda_codec *codec)
19539{
19540	struct alc_spec *spec = codec->spec;
19541	struct auto_pin_cfg *cfg = &spec->autocfg;
19542	int pin_found = 0;
19543	int type_found = AUTO_PIN_LAST;
19544	hda_nid_t nid;
19545	int i;
19546
19547	for (i = 0; i < cfg->num_inputs; i++) {
19548		nid = cfg->inputs[i].pin;
19549		if (!(snd_hda_query_pin_caps(codec, nid) &
19550		      AC_PINCAP_PRES_DETECT))
19551			continue;
19552		if (snd_hda_jack_detect(codec, nid)) {
19553			if (cfg->inputs[i].type < type_found) {
19554				type_found = cfg->inputs[i].type;
19555				pin_found = nid;
19556			}
19557		}
19558	}
19559
19560	nid = 0x07;
19561	if (pin_found)
19562		snd_hda_get_connections(codec, pin_found, &nid, 1);
19563
19564	if (nid != spec->cur_adc)
19565		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19566	spec->cur_adc = nid;
19567	snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19568				   spec->cur_adc_format);
19569}
19570
19571static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19572				      struct hda_codec *codec,
19573				      unsigned int stream_tag,
19574				      unsigned int format,
19575				      struct snd_pcm_substream *substream)
19576{
19577	struct alc_spec *spec = codec->spec;
19578
19579	spec->cur_adc = 0x07;
19580	spec->cur_adc_stream_tag = stream_tag;
19581	spec->cur_adc_format = format;
19582
19583	alc680_rec_autoswitch(codec);
19584	return 0;
19585}
19586
19587static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19588				      struct hda_codec *codec,
19589				      struct snd_pcm_substream *substream)
19590{
19591	snd_hda_codec_cleanup_stream(codec, 0x07);
19592	snd_hda_codec_cleanup_stream(codec, 0x08);
19593	snd_hda_codec_cleanup_stream(codec, 0x09);
19594	return 0;
19595}
19596
19597static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19598	.substreams = 1, /* can be overridden */
19599	.channels_min = 2,
19600	.channels_max = 2,
19601	/* NID is set in alc_build_pcms */
19602	.ops = {
19603		.prepare = alc680_capture_pcm_prepare,
19604		.cleanup = alc680_capture_pcm_cleanup
19605	},
19606};
19607
19608static struct snd_kcontrol_new alc680_base_mixer[] = {
19609	/* output mixer control */
19610	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19611	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19612	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19613	HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19614	HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
19615	HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
19616	HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
19617	{ }
19618};
19619
19620static struct hda_bind_ctls alc680_bind_cap_vol = {
19621	.ops = &snd_hda_bind_vol,
19622	.values = {
19623		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19624		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19625		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19626		0
19627	},
19628};
19629
19630static struct hda_bind_ctls alc680_bind_cap_switch = {
19631	.ops = &snd_hda_bind_sw,
19632	.values = {
19633		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19634		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19635		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19636		0
19637	},
19638};
19639
19640static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19641	HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19642	HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19643	{ } /* end */
19644};
19645
19646/*
19647 * generic initialization of ADC, input mixers and output mixers
19648 */
19649static struct hda_verb alc680_init_verbs[] = {
19650	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19651	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19652	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19653
19654	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19655	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19656	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19657	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19658	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19659	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19660
19661	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19662	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19663	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19664	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19665	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19666
19667	{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19668	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19669	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19670
19671	{ }
19672};
19673
19674/* toggle speaker-output according to the hp-jack state */
19675static void alc680_base_setup(struct hda_codec *codec)
19676{
19677	struct alc_spec *spec = codec->spec;
19678
19679	spec->autocfg.hp_pins[0] = 0x16;
19680	spec->autocfg.speaker_pins[0] = 0x14;
19681	spec->autocfg.speaker_pins[1] = 0x15;
19682	spec->autocfg.num_inputs = 2;
19683	spec->autocfg.inputs[0].pin = 0x18;
19684	spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19685	spec->autocfg.inputs[1].pin = 0x19;
19686	spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19687}
19688
19689static void alc680_unsol_event(struct hda_codec *codec,
19690					   unsigned int res)
19691{
19692	if ((res >> 26) == ALC880_HP_EVENT)
19693		alc_automute_amp(codec);
19694	if ((res >> 26) == ALC880_MIC_EVENT)
19695		alc680_rec_autoswitch(codec);
19696}
19697
19698static void alc680_inithook(struct hda_codec *codec)
19699{
19700	alc_automute_amp(codec);
19701	alc680_rec_autoswitch(codec);
19702}
19703
19704/* create input playback/capture controls for the given pin */
19705static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19706				    const char *ctlname, int idx)
19707{
19708	hda_nid_t dac;
19709	int err;
19710
19711	switch (nid) {
19712	case 0x14:
19713		dac = 0x02;
19714		break;
19715	case 0x15:
19716		dac = 0x03;
19717		break;
19718	case 0x16:
19719		dac = 0x04;
19720		break;
19721	default:
19722		return 0;
19723	}
19724	if (spec->multiout.dac_nids[0] != dac &&
19725	    spec->multiout.dac_nids[1] != dac) {
19726		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19727				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19728						      HDA_OUTPUT));
19729		if (err < 0)
19730			return err;
19731
19732		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19733			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19734
19735		if (err < 0)
19736			return err;
19737		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19738	}
19739
19740	return 0;
19741}
19742
19743/* add playback controls from the parsed DAC table */
19744static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19745					     const struct auto_pin_cfg *cfg)
19746{
19747	hda_nid_t nid;
19748	int err;
19749
19750	spec->multiout.dac_nids = spec->private_dac_nids;
19751
19752	nid = cfg->line_out_pins[0];
19753	if (nid) {
19754		const char *name;
19755		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19756			name = "Speaker";
19757		else
19758			name = "Front";
19759		err = alc680_new_analog_output(spec, nid, name, 0);
19760		if (err < 0)
19761			return err;
19762	}
19763
19764	nid = cfg->speaker_pins[0];
19765	if (nid) {
19766		err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19767		if (err < 0)
19768			return err;
19769	}
19770	nid = cfg->hp_pins[0];
19771	if (nid) {
19772		err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19773		if (err < 0)
19774			return err;
19775	}
19776
19777	return 0;
19778}
19779
19780static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19781					      hda_nid_t nid, int pin_type)
19782{
19783	alc_set_pin_output(codec, nid, pin_type);
19784}
19785
19786static void alc680_auto_init_multi_out(struct hda_codec *codec)
19787{
19788	struct alc_spec *spec = codec->spec;
19789	hda_nid_t nid = spec->autocfg.line_out_pins[0];
19790	if (nid) {
19791		int pin_type = get_pin_type(spec->autocfg.line_out_type);
19792		alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19793	}
19794}
19795
19796static void alc680_auto_init_hp_out(struct hda_codec *codec)
19797{
19798	struct alc_spec *spec = codec->spec;
19799	hda_nid_t pin;
19800
19801	pin = spec->autocfg.hp_pins[0];
19802	if (pin)
19803		alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19804	pin = spec->autocfg.speaker_pins[0];
19805	if (pin)
19806		alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19807}
19808
19809/* pcm configuration: identical with ALC880 */
19810#define alc680_pcm_analog_playback	alc880_pcm_analog_playback
19811#define alc680_pcm_analog_capture	alc880_pcm_analog_capture
19812#define alc680_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
19813#define alc680_pcm_digital_playback	alc880_pcm_digital_playback
19814#define alc680_pcm_digital_capture	alc880_pcm_digital_capture
19815
19816/*
19817 * BIOS auto configuration
19818 */
19819static int alc680_parse_auto_config(struct hda_codec *codec)
19820{
19821	struct alc_spec *spec = codec->spec;
19822	int err;
19823	static hda_nid_t alc680_ignore[] = { 0 };
19824
19825	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19826					   alc680_ignore);
19827	if (err < 0)
19828		return err;
19829
19830	if (!spec->autocfg.line_outs) {
19831		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19832			spec->multiout.max_channels = 2;
19833			spec->no_analog = 1;
19834			goto dig_only;
19835		}
19836		return 0; /* can't find valid BIOS pin config */
19837	}
19838	err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19839	if (err < 0)
19840		return err;
19841
19842	spec->multiout.max_channels = 2;
19843
19844 dig_only:
19845	/* digital only support output */
19846	alc_auto_parse_digital(codec);
19847	if (spec->kctls.list)
19848		add_mixer(spec, spec->kctls.list);
19849
19850	add_verb(spec, alc680_init_verbs);
19851
19852	err = alc_auto_add_mic_boost(codec);
19853	if (err < 0)
19854		return err;
19855
19856	return 1;
19857}
19858
19859#define alc680_auto_init_analog_input	alc882_auto_init_analog_input
19860
19861/* init callback for auto-configuration model -- overriding the default init */
19862static void alc680_auto_init(struct hda_codec *codec)
19863{
19864	struct alc_spec *spec = codec->spec;
19865	alc680_auto_init_multi_out(codec);
19866	alc680_auto_init_hp_out(codec);
19867	alc680_auto_init_analog_input(codec);
19868	alc_auto_init_digital(codec);
19869	if (spec->unsol_event)
19870		alc_inithook(codec);
19871}
19872
19873/*
19874 * configuration and preset
19875 */
19876static const char *alc680_models[ALC680_MODEL_LAST] = {
19877	[ALC680_BASE]		= "base",
19878	[ALC680_AUTO]		= "auto",
19879};
19880
19881static struct snd_pci_quirk alc680_cfg_tbl[] = {
19882	SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19883	{}
19884};
19885
19886static struct alc_config_preset alc680_presets[] = {
19887	[ALC680_BASE] = {
19888		.mixers = { alc680_base_mixer },
19889		.cap_mixer =  alc680_master_capture_mixer,
19890		.init_verbs = { alc680_init_verbs },
19891		.num_dacs = ARRAY_SIZE(alc680_dac_nids),
19892		.dac_nids = alc680_dac_nids,
19893		.dig_out_nid = ALC680_DIGOUT_NID,
19894		.num_channel_mode = ARRAY_SIZE(alc680_modes),
19895		.channel_mode = alc680_modes,
19896		.unsol_event = alc680_unsol_event,
19897		.setup = alc680_base_setup,
19898		.init_hook = alc680_inithook,
19899
19900	},
19901};
19902
19903static int patch_alc680(struct hda_codec *codec)
19904{
19905	struct alc_spec *spec;
19906	int board_config;
19907	int err;
19908
19909	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19910	if (spec == NULL)
19911		return -ENOMEM;
19912
19913	codec->spec = spec;
19914
19915	board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19916						  alc680_models,
19917						  alc680_cfg_tbl);
19918
19919	if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19920		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19921		       codec->chip_name);
19922		board_config = ALC680_AUTO;
19923	}
19924
19925	if (board_config == ALC680_AUTO) {
19926		/* automatic parse from the BIOS config */
19927		err = alc680_parse_auto_config(codec);
19928		if (err < 0) {
19929			alc_free(codec);
19930			return err;
19931		} else if (!err) {
19932			printk(KERN_INFO
19933			       "hda_codec: Cannot set up configuration "
19934			       "from BIOS.  Using base mode...\n");
19935			board_config = ALC680_BASE;
19936		}
19937	}
19938
19939	if (board_config != ALC680_AUTO)
19940		setup_preset(codec, &alc680_presets[board_config]);
19941
19942	spec->stream_analog_playback = &alc680_pcm_analog_playback;
19943	spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19944	spec->stream_digital_playback = &alc680_pcm_digital_playback;
19945	spec->stream_digital_capture = &alc680_pcm_digital_capture;
19946
19947	if (!spec->adc_nids) {
19948		spec->adc_nids = alc680_adc_nids;
19949		spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19950	}
19951
19952	if (!spec->cap_mixer)
19953		set_capture_mixer(codec);
19954
19955	spec->vmaster_nid = 0x02;
19956
19957	codec->patch_ops = alc_patch_ops;
19958	if (board_config == ALC680_AUTO)
19959		spec->init_hook = alc680_auto_init;
19960
19961	return 0;
19962}
19963
19964/*
19965 * patch entries
19966 */
19967static struct hda_codec_preset snd_hda_preset_realtek[] = {
19968	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
19969	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
19970	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
19971	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
19972	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
19973	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
19974	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
19975	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
19976	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
19977	  .patch = patch_alc861 },
19978	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
19979	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
19980	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
19981	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
19982	  .patch = patch_alc882 },
19983	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
19984	  .patch = patch_alc662 },
19985	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
19986	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
19987	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
19988	{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
19989	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
19990	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
19991	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
19992	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
19993	  .patch = patch_alc882 },
19994	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
19995	  .patch = patch_alc882 },
19996	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
19997	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
19998	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
19999	  .patch = patch_alc882 },
20000	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20001	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20002	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20003	{} /* terminator */
20004};
20005
20006MODULE_ALIAS("snd-hda-codec-id:10ec*");
20007
20008MODULE_LICENSE("GPL");
20009MODULE_DESCRIPTION("Realtek HD-audio codec");
20010
20011static struct hda_codec_preset_list realtek_list = {
20012	.preset = snd_hda_preset_realtek,
20013	.owner = THIS_MODULE,
20014};
20015
20016static int __init patch_realtek_init(void)
20017{
20018	return snd_hda_add_codec_preset(&realtek_list);
20019}
20020
20021static void __exit patch_realtek_exit(void)
20022{
20023	snd_hda_delete_codec_preset(&realtek_list);
20024}
20025
20026module_init(patch_realtek_init)
20027module_exit(patch_realtek_exit)
20028