patch_realtek.c revision ae0ebbf70afe2889b39f575e800e7292abd259d6 
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_WIM2160,
235	ALC883_LAPTOP_EAPD,
236	ALC883_LENOVO_101E_2ch,
237	ALC883_LENOVO_NB0763,
238	ALC888_LENOVO_MS7195_DIG,
239	ALC888_LENOVO_SKY,
240	ALC883_HAIER_W66,
241	ALC888_3ST_HP,
242	ALC888_6ST_DELL,
243	ALC883_MITAC,
244	ALC883_CLEVO_M540R,
245	ALC883_CLEVO_M720,
246	ALC883_FUJITSU_PI2515,
247	ALC888_FUJITSU_XA3530,
248	ALC883_3ST_6ch_INTEL,
249	ALC889A_INTEL,
250	ALC889_INTEL,
251	ALC888_ASUS_M90V,
252	ALC888_ASUS_EEE1601,
253	ALC889A_MB31,
254	ALC1200_ASUS_P5Q,
255	ALC883_SONY_VAIO_TT,
256	ALC882_AUTO,
257	ALC882_MODEL_LAST,
258};
259
260/* ALC680 models */
261enum {
262	ALC680_BASE,
263	ALC680_AUTO,
264	ALC680_MODEL_LAST,
265};
266
267/* for GPIO Poll */
268#define GPIO_MASK	0x03
269
270/* extra amp-initialization sequence types */
271enum {
272	ALC_INIT_NONE,
273	ALC_INIT_DEFAULT,
274	ALC_INIT_GPIO1,
275	ALC_INIT_GPIO2,
276	ALC_INIT_GPIO3,
277};
278
279struct alc_mic_route {
280	hda_nid_t pin;
281	unsigned char mux_idx;
282	unsigned char amix_idx;
283};
284
285#define MUX_IDX_UNDEF	((unsigned char)-1)
286
287struct alc_customize_define {
288	unsigned int  sku_cfg;
289	unsigned char port_connectivity;
290	unsigned char check_sum;
291	unsigned char customization;
292	unsigned char external_amp;
293	unsigned int  enable_pcbeep:1;
294	unsigned int  platform_type:1;
295	unsigned int  swap:1;
296	unsigned int  override:1;
297	unsigned int  fixup:1; /* Means that this sku is set by driver, not read from hw */
298};
299
300struct alc_fixup;
301
302struct alc_spec {
303	/* codec parameterization */
304	struct snd_kcontrol_new *mixers[5];	/* mixer arrays */
305	unsigned int num_mixers;
306	struct snd_kcontrol_new *cap_mixer;	/* capture mixer */
307	unsigned int beep_amp;	/* beep amp value, set via set_beep_amp() */
308
309	const struct hda_verb *init_verbs[10];	/* initialization verbs
310						 * don't forget NULL
311						 * termination!
312						 */
313	unsigned int num_init_verbs;
314
315	char stream_name_analog[32];	/* analog PCM stream */
316	struct hda_pcm_stream *stream_analog_playback;
317	struct hda_pcm_stream *stream_analog_capture;
318	struct hda_pcm_stream *stream_analog_alt_playback;
319	struct hda_pcm_stream *stream_analog_alt_capture;
320
321	char stream_name_digital[32];	/* digital PCM stream */
322	struct hda_pcm_stream *stream_digital_playback;
323	struct hda_pcm_stream *stream_digital_capture;
324
325	/* playback */
326	struct hda_multi_out multiout;	/* playback set-up
327					 * max_channels, dacs must be set
328					 * dig_out_nid and hp_nid are optional
329					 */
330	hda_nid_t alt_dac_nid;
331	hda_nid_t slave_dig_outs[3];	/* optional - for auto-parsing */
332	int dig_out_type;
333
334	/* capture */
335	unsigned int num_adc_nids;
336	hda_nid_t *adc_nids;
337	hda_nid_t *capsrc_nids;
338	hda_nid_t dig_in_nid;		/* digital-in NID; optional */
339
340	/* capture setup for dynamic dual-adc switch */
341	unsigned int cur_adc_idx;
342	hda_nid_t cur_adc;
343	unsigned int cur_adc_stream_tag;
344	unsigned int cur_adc_format;
345
346	/* capture source */
347	unsigned int num_mux_defs;
348	const struct hda_input_mux *input_mux;
349	unsigned int cur_mux[3];
350	struct alc_mic_route ext_mic;
351	struct alc_mic_route int_mic;
352
353	/* channel model */
354	const struct hda_channel_mode *channel_mode;
355	int num_channel_mode;
356	int need_dac_fix;
357	int const_channel_count;
358	int ext_channel_count;
359
360	/* PCM information */
361	struct hda_pcm pcm_rec[3];	/* used in alc_build_pcms() */
362
363	/* dynamic controls, init_verbs and input_mux */
364	struct auto_pin_cfg autocfg;
365	struct alc_customize_define cdefine;
366	struct snd_array kctls;
367	struct hda_input_mux private_imux[3];
368	hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
369	hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
370	hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
371
372	/* hooks */
373	void (*init_hook)(struct hda_codec *codec);
374	void (*unsol_event)(struct hda_codec *codec, unsigned int res);
375#ifdef CONFIG_SND_HDA_POWER_SAVE
376	void (*power_hook)(struct hda_codec *codec);
377#endif
378
379	/* for pin sensing */
380	unsigned int sense_updated: 1;
381	unsigned int jack_present: 1;
382	unsigned int master_sw: 1;
383	unsigned int auto_mic:1;
384
385	/* other flags */
386	unsigned int no_analog :1; /* digital I/O only */
387	unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
388	unsigned int single_input_src:1;
389	int init_amp;
390	int codec_variant;	/* flag for other variants */
391
392	/* for virtual master */
393	hda_nid_t vmaster_nid;
394#ifdef CONFIG_SND_HDA_POWER_SAVE
395	struct hda_loopback_check loopback;
396#endif
397
398	/* for PLL fix */
399	hda_nid_t pll_nid;
400	unsigned int pll_coef_idx, pll_coef_bit;
401
402	/* fix-up list */
403	int fixup_id;
404	const struct alc_fixup *fixup_list;
405	const char *fixup_name;
406};
407
408/*
409 * configuration template - to be copied to the spec instance
410 */
411struct alc_config_preset {
412	struct snd_kcontrol_new *mixers[5]; /* should be identical size
413					     * with spec
414					     */
415	struct snd_kcontrol_new *cap_mixer; /* capture mixer */
416	const struct hda_verb *init_verbs[5];
417	unsigned int num_dacs;
418	hda_nid_t *dac_nids;
419	hda_nid_t dig_out_nid;		/* optional */
420	hda_nid_t hp_nid;		/* optional */
421	hda_nid_t *slave_dig_outs;
422	unsigned int num_adc_nids;
423	hda_nid_t *adc_nids;
424	hda_nid_t *capsrc_nids;
425	hda_nid_t dig_in_nid;
426	unsigned int num_channel_mode;
427	const struct hda_channel_mode *channel_mode;
428	int need_dac_fix;
429	int const_channel_count;
430	unsigned int num_mux_defs;
431	const struct hda_input_mux *input_mux;
432	void (*unsol_event)(struct hda_codec *, unsigned int);
433	void (*setup)(struct hda_codec *);
434	void (*init_hook)(struct hda_codec *);
435#ifdef CONFIG_SND_HDA_POWER_SAVE
436	struct hda_amp_list *loopbacks;
437	void (*power_hook)(struct hda_codec *codec);
438#endif
439};
440
441
442/*
443 * input MUX handling
444 */
445static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
446			     struct snd_ctl_elem_info *uinfo)
447{
448	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
449	struct alc_spec *spec = codec->spec;
450	unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
451	if (mux_idx >= spec->num_mux_defs)
452		mux_idx = 0;
453	if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
454		mux_idx = 0;
455	return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
456}
457
458static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
459			    struct snd_ctl_elem_value *ucontrol)
460{
461	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
462	struct alc_spec *spec = codec->spec;
463	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
464
465	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
466	return 0;
467}
468
469static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
470			    struct snd_ctl_elem_value *ucontrol)
471{
472	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
473	struct alc_spec *spec = codec->spec;
474	const struct hda_input_mux *imux;
475	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
476	unsigned int mux_idx;
477	hda_nid_t nid = spec->capsrc_nids ?
478		spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
479	unsigned int type;
480
481	mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
482	imux = &spec->input_mux[mux_idx];
483	if (!imux->num_items && mux_idx > 0)
484		imux = &spec->input_mux[0];
485
486	type = get_wcaps_type(get_wcaps(codec, nid));
487	if (type == AC_WID_AUD_MIX) {
488		/* Matrix-mixer style (e.g. ALC882) */
489		unsigned int *cur_val = &spec->cur_mux[adc_idx];
490		unsigned int i, idx;
491
492		idx = ucontrol->value.enumerated.item[0];
493		if (idx >= imux->num_items)
494			idx = imux->num_items - 1;
495		if (*cur_val == idx)
496			return 0;
497		for (i = 0; i < imux->num_items; i++) {
498			unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
499			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
500						 imux->items[i].index,
501						 HDA_AMP_MUTE, v);
502		}
503		*cur_val = idx;
504		return 1;
505	} else {
506		/* MUX style (e.g. ALC880) */
507		return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
508					     &spec->cur_mux[adc_idx]);
509	}
510}
511
512/*
513 * channel mode setting
514 */
515static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
516			    struct snd_ctl_elem_info *uinfo)
517{
518	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
519	struct alc_spec *spec = codec->spec;
520	return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
521				    spec->num_channel_mode);
522}
523
524static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
525			   struct snd_ctl_elem_value *ucontrol)
526{
527	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
528	struct alc_spec *spec = codec->spec;
529	return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
530				   spec->num_channel_mode,
531				   spec->ext_channel_count);
532}
533
534static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
535			   struct snd_ctl_elem_value *ucontrol)
536{
537	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
538	struct alc_spec *spec = codec->spec;
539	int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
540				      spec->num_channel_mode,
541				      &spec->ext_channel_count);
542	if (err >= 0 && !spec->const_channel_count) {
543		spec->multiout.max_channels = spec->ext_channel_count;
544		if (spec->need_dac_fix)
545			spec->multiout.num_dacs = spec->multiout.max_channels / 2;
546	}
547	return err;
548}
549
550/*
551 * Control the mode of pin widget settings via the mixer.  "pc" is used
552 * instead of "%" to avoid consequences of accidently treating the % as
553 * being part of a format specifier.  Maximum allowed length of a value is
554 * 63 characters plus NULL terminator.
555 *
556 * Note: some retasking pin complexes seem to ignore requests for input
557 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
558 * are requested.  Therefore order this list so that this behaviour will not
559 * cause problems when mixer clients move through the enum sequentially.
560 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
561 * March 2006.
562 */
563static char *alc_pin_mode_names[] = {
564	"Mic 50pc bias", "Mic 80pc bias",
565	"Line in", "Line out", "Headphone out",
566};
567static unsigned char alc_pin_mode_values[] = {
568	PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
569};
570/* The control can present all 5 options, or it can limit the options based
571 * in the pin being assumed to be exclusively an input or an output pin.  In
572 * addition, "input" pins may or may not process the mic bias option
573 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
574 * accept requests for bias as of chip versions up to March 2006) and/or
575 * wiring in the computer.
576 */
577#define ALC_PIN_DIR_IN              0x00
578#define ALC_PIN_DIR_OUT             0x01
579#define ALC_PIN_DIR_INOUT           0x02
580#define ALC_PIN_DIR_IN_NOMICBIAS    0x03
581#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
582
583/* Info about the pin modes supported by the different pin direction modes.
584 * For each direction the minimum and maximum values are given.
585 */
586static signed char alc_pin_mode_dir_info[5][2] = {
587	{ 0, 2 },    /* ALC_PIN_DIR_IN */
588	{ 3, 4 },    /* ALC_PIN_DIR_OUT */
589	{ 0, 4 },    /* ALC_PIN_DIR_INOUT */
590	{ 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
591	{ 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
592};
593#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
594#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
595#define alc_pin_mode_n_items(_dir) \
596	(alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
597
598static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
599			     struct snd_ctl_elem_info *uinfo)
600{
601	unsigned int item_num = uinfo->value.enumerated.item;
602	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
603
604	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
605	uinfo->count = 1;
606	uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
607
608	if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
609		item_num = alc_pin_mode_min(dir);
610	strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
611	return 0;
612}
613
614static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
615			    struct snd_ctl_elem_value *ucontrol)
616{
617	unsigned int i;
618	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
619	hda_nid_t nid = kcontrol->private_value & 0xffff;
620	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
621	long *valp = ucontrol->value.integer.value;
622	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
623						 AC_VERB_GET_PIN_WIDGET_CONTROL,
624						 0x00);
625
626	/* Find enumerated value for current pinctl setting */
627	i = alc_pin_mode_min(dir);
628	while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
629		i++;
630	*valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
631	return 0;
632}
633
634static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
635			    struct snd_ctl_elem_value *ucontrol)
636{
637	signed int change;
638	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
639	hda_nid_t nid = kcontrol->private_value & 0xffff;
640	unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
641	long val = *ucontrol->value.integer.value;
642	unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
643						 AC_VERB_GET_PIN_WIDGET_CONTROL,
644						 0x00);
645
646	if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
647		val = alc_pin_mode_min(dir);
648
649	change = pinctl != alc_pin_mode_values[val];
650	if (change) {
651		/* Set pin mode to that requested */
652		snd_hda_codec_write_cache(codec, nid, 0,
653					  AC_VERB_SET_PIN_WIDGET_CONTROL,
654					  alc_pin_mode_values[val]);
655
656		/* Also enable the retasking pin's input/output as required
657		 * for the requested pin mode.  Enum values of 2 or less are
658		 * input modes.
659		 *
660		 * Dynamically switching the input/output buffers probably
661		 * reduces noise slightly (particularly on input) so we'll
662		 * do it.  However, having both input and output buffers
663		 * enabled simultaneously doesn't seem to be problematic if
664		 * this turns out to be necessary in the future.
665		 */
666		if (val <= 2) {
667			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
668						 HDA_AMP_MUTE, HDA_AMP_MUTE);
669			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
670						 HDA_AMP_MUTE, 0);
671		} else {
672			snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
673						 HDA_AMP_MUTE, HDA_AMP_MUTE);
674			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
675						 HDA_AMP_MUTE, 0);
676		}
677	}
678	return change;
679}
680
681#define ALC_PIN_MODE(xname, nid, dir) \
682	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
683	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
684	  .info = alc_pin_mode_info, \
685	  .get = alc_pin_mode_get, \
686	  .put = alc_pin_mode_put, \
687	  .private_value = nid | (dir<<16) }
688
689/* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
690 * together using a mask with more than one bit set.  This control is
691 * currently used only by the ALC260 test model.  At this stage they are not
692 * needed for any "production" models.
693 */
694#ifdef CONFIG_SND_DEBUG
695#define alc_gpio_data_info	snd_ctl_boolean_mono_info
696
697static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
698			     struct snd_ctl_elem_value *ucontrol)
699{
700	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
701	hda_nid_t nid = kcontrol->private_value & 0xffff;
702	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
703	long *valp = ucontrol->value.integer.value;
704	unsigned int val = snd_hda_codec_read(codec, nid, 0,
705					      AC_VERB_GET_GPIO_DATA, 0x00);
706
707	*valp = (val & mask) != 0;
708	return 0;
709}
710static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
711			     struct snd_ctl_elem_value *ucontrol)
712{
713	signed int change;
714	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
715	hda_nid_t nid = kcontrol->private_value & 0xffff;
716	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
717	long val = *ucontrol->value.integer.value;
718	unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
719						    AC_VERB_GET_GPIO_DATA,
720						    0x00);
721
722	/* Set/unset the masked GPIO bit(s) as needed */
723	change = (val == 0 ? 0 : mask) != (gpio_data & mask);
724	if (val == 0)
725		gpio_data &= ~mask;
726	else
727		gpio_data |= mask;
728	snd_hda_codec_write_cache(codec, nid, 0,
729				  AC_VERB_SET_GPIO_DATA, gpio_data);
730
731	return change;
732}
733#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
734	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
735	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
736	  .info = alc_gpio_data_info, \
737	  .get = alc_gpio_data_get, \
738	  .put = alc_gpio_data_put, \
739	  .private_value = nid | (mask<<16) }
740#endif   /* CONFIG_SND_DEBUG */
741
742/* A switch control to allow the enabling of the digital IO pins on the
743 * ALC260.  This is incredibly simplistic; the intention of this control is
744 * to provide something in the test model allowing digital outputs to be
745 * identified if present.  If models are found which can utilise these
746 * outputs a more complete mixer control can be devised for those models if
747 * necessary.
748 */
749#ifdef CONFIG_SND_DEBUG
750#define alc_spdif_ctrl_info	snd_ctl_boolean_mono_info
751
752static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
753			      struct snd_ctl_elem_value *ucontrol)
754{
755	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
756	hda_nid_t nid = kcontrol->private_value & 0xffff;
757	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
758	long *valp = ucontrol->value.integer.value;
759	unsigned int val = snd_hda_codec_read(codec, nid, 0,
760					      AC_VERB_GET_DIGI_CONVERT_1, 0x00);
761
762	*valp = (val & mask) != 0;
763	return 0;
764}
765static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
766			      struct snd_ctl_elem_value *ucontrol)
767{
768	signed int change;
769	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
770	hda_nid_t nid = kcontrol->private_value & 0xffff;
771	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
772	long val = *ucontrol->value.integer.value;
773	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
774						    AC_VERB_GET_DIGI_CONVERT_1,
775						    0x00);
776
777	/* Set/unset the masked control bit(s) as needed */
778	change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
779	if (val==0)
780		ctrl_data &= ~mask;
781	else
782		ctrl_data |= mask;
783	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
784				  ctrl_data);
785
786	return change;
787}
788#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
789	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
790	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
791	  .info = alc_spdif_ctrl_info, \
792	  .get = alc_spdif_ctrl_get, \
793	  .put = alc_spdif_ctrl_put, \
794	  .private_value = nid | (mask<<16) }
795#endif   /* CONFIG_SND_DEBUG */
796
797/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
798 * Again, this is only used in the ALC26x test models to help identify when
799 * the EAPD line must be asserted for features to work.
800 */
801#ifdef CONFIG_SND_DEBUG
802#define alc_eapd_ctrl_info	snd_ctl_boolean_mono_info
803
804static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
805			      struct snd_ctl_elem_value *ucontrol)
806{
807	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
808	hda_nid_t nid = kcontrol->private_value & 0xffff;
809	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
810	long *valp = ucontrol->value.integer.value;
811	unsigned int val = snd_hda_codec_read(codec, nid, 0,
812					      AC_VERB_GET_EAPD_BTLENABLE, 0x00);
813
814	*valp = (val & mask) != 0;
815	return 0;
816}
817
818static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
819			      struct snd_ctl_elem_value *ucontrol)
820{
821	int change;
822	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
823	hda_nid_t nid = kcontrol->private_value & 0xffff;
824	unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
825	long val = *ucontrol->value.integer.value;
826	unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
827						    AC_VERB_GET_EAPD_BTLENABLE,
828						    0x00);
829
830	/* Set/unset the masked control bit(s) as needed */
831	change = (!val ? 0 : mask) != (ctrl_data & mask);
832	if (!val)
833		ctrl_data &= ~mask;
834	else
835		ctrl_data |= mask;
836	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
837				  ctrl_data);
838
839	return change;
840}
841
842#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
843	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
844	  .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
845	  .info = alc_eapd_ctrl_info, \
846	  .get = alc_eapd_ctrl_get, \
847	  .put = alc_eapd_ctrl_put, \
848	  .private_value = nid | (mask<<16) }
849#endif   /* CONFIG_SND_DEBUG */
850
851/*
852 * set up the input pin config (depending on the given auto-pin type)
853 */
854static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
855			      int auto_pin_type)
856{
857	unsigned int val = PIN_IN;
858
859	if (auto_pin_type == AUTO_PIN_MIC) {
860		unsigned int pincap;
861		unsigned int oldval;
862		oldval = snd_hda_codec_read(codec, nid, 0,
863					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
864		pincap = snd_hda_query_pin_caps(codec, nid);
865		pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
866		/* if the default pin setup is vref50, we give it priority */
867		if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
868			val = PIN_VREF80;
869		else if (pincap & AC_PINCAP_VREF_50)
870			val = PIN_VREF50;
871		else if (pincap & AC_PINCAP_VREF_100)
872			val = PIN_VREF100;
873		else if (pincap & AC_PINCAP_VREF_GRD)
874			val = PIN_VREFGRD;
875	}
876	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
877}
878
879static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec)
880{
881	struct alc_spec *spec = codec->spec;
882	struct auto_pin_cfg *cfg = &spec->autocfg;
883
884	if (!cfg->line_outs) {
885		while (cfg->line_outs < AUTO_CFG_MAX_OUTS &&
886		       cfg->line_out_pins[cfg->line_outs])
887			cfg->line_outs++;
888	}
889	if (!cfg->speaker_outs) {
890		while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS &&
891		       cfg->speaker_pins[cfg->speaker_outs])
892			cfg->speaker_outs++;
893	}
894	if (!cfg->hp_outs) {
895		while (cfg->hp_outs < AUTO_CFG_MAX_OUTS &&
896		       cfg->hp_pins[cfg->hp_outs])
897			cfg->hp_outs++;
898	}
899}
900
901/*
902 */
903static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
904{
905	if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
906		return;
907	spec->mixers[spec->num_mixers++] = mix;
908}
909
910static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
911{
912	if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
913		return;
914	spec->init_verbs[spec->num_init_verbs++] = verb;
915}
916
917/*
918 * set up from the preset table
919 */
920static void setup_preset(struct hda_codec *codec,
921			 const struct alc_config_preset *preset)
922{
923	struct alc_spec *spec = codec->spec;
924	int i;
925
926	for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
927		add_mixer(spec, preset->mixers[i]);
928	spec->cap_mixer = preset->cap_mixer;
929	for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
930	     i++)
931		add_verb(spec, preset->init_verbs[i]);
932
933	spec->channel_mode = preset->channel_mode;
934	spec->num_channel_mode = preset->num_channel_mode;
935	spec->need_dac_fix = preset->need_dac_fix;
936	spec->const_channel_count = preset->const_channel_count;
937
938	if (preset->const_channel_count)
939		spec->multiout.max_channels = preset->const_channel_count;
940	else
941		spec->multiout.max_channels = spec->channel_mode[0].channels;
942	spec->ext_channel_count = spec->channel_mode[0].channels;
943
944	spec->multiout.num_dacs = preset->num_dacs;
945	spec->multiout.dac_nids = preset->dac_nids;
946	spec->multiout.dig_out_nid = preset->dig_out_nid;
947	spec->multiout.slave_dig_outs = preset->slave_dig_outs;
948	spec->multiout.hp_nid = preset->hp_nid;
949
950	spec->num_mux_defs = preset->num_mux_defs;
951	if (!spec->num_mux_defs)
952		spec->num_mux_defs = 1;
953	spec->input_mux = preset->input_mux;
954
955	spec->num_adc_nids = preset->num_adc_nids;
956	spec->adc_nids = preset->adc_nids;
957	spec->capsrc_nids = preset->capsrc_nids;
958	spec->dig_in_nid = preset->dig_in_nid;
959
960	spec->unsol_event = preset->unsol_event;
961	spec->init_hook = preset->init_hook;
962#ifdef CONFIG_SND_HDA_POWER_SAVE
963	spec->power_hook = preset->power_hook;
964	spec->loopback.amplist = preset->loopbacks;
965#endif
966
967	if (preset->setup)
968		preset->setup(codec);
969
970	alc_fixup_autocfg_pin_nums(codec);
971}
972
973/* Enable GPIO mask and set output */
974static struct hda_verb alc_gpio1_init_verbs[] = {
975	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
976	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
977	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
978	{ }
979};
980
981static struct hda_verb alc_gpio2_init_verbs[] = {
982	{0x01, AC_VERB_SET_GPIO_MASK, 0x02},
983	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
984	{0x01, AC_VERB_SET_GPIO_DATA, 0x02},
985	{ }
986};
987
988static struct hda_verb alc_gpio3_init_verbs[] = {
989	{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
990	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
991	{0x01, AC_VERB_SET_GPIO_DATA, 0x03},
992	{ }
993};
994
995/*
996 * Fix hardware PLL issue
997 * On some codecs, the analog PLL gating control must be off while
998 * the default value is 1.
999 */
1000static void alc_fix_pll(struct hda_codec *codec)
1001{
1002	struct alc_spec *spec = codec->spec;
1003	unsigned int val;
1004
1005	if (!spec->pll_nid)
1006		return;
1007	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1008			    spec->pll_coef_idx);
1009	val = snd_hda_codec_read(codec, spec->pll_nid, 0,
1010				 AC_VERB_GET_PROC_COEF, 0);
1011	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
1012			    spec->pll_coef_idx);
1013	snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
1014			    val & ~(1 << spec->pll_coef_bit));
1015}
1016
1017static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
1018			     unsigned int coef_idx, unsigned int coef_bit)
1019{
1020	struct alc_spec *spec = codec->spec;
1021	spec->pll_nid = nid;
1022	spec->pll_coef_idx = coef_idx;
1023	spec->pll_coef_bit = coef_bit;
1024	alc_fix_pll(codec);
1025}
1026
1027static int alc_init_jacks(struct hda_codec *codec)
1028{
1029#ifdef CONFIG_SND_HDA_INPUT_JACK
1030	struct alc_spec *spec = codec->spec;
1031	int err;
1032	unsigned int hp_nid = spec->autocfg.hp_pins[0];
1033	unsigned int mic_nid = spec->ext_mic.pin;
1034
1035	if (hp_nid) {
1036		err = snd_hda_input_jack_add(codec, hp_nid,
1037					     SND_JACK_HEADPHONE, NULL);
1038		if (err < 0)
1039			return err;
1040		snd_hda_input_jack_report(codec, hp_nid);
1041	}
1042
1043	if (mic_nid) {
1044		err = snd_hda_input_jack_add(codec, mic_nid,
1045					     SND_JACK_MICROPHONE, NULL);
1046		if (err < 0)
1047			return err;
1048		snd_hda_input_jack_report(codec, mic_nid);
1049	}
1050#endif /* CONFIG_SND_HDA_INPUT_JACK */
1051	return 0;
1052}
1053
1054static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
1055{
1056	struct alc_spec *spec = codec->spec;
1057	unsigned int mute;
1058	hda_nid_t nid;
1059	int i;
1060
1061	spec->jack_present = 0;
1062	for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1063		nid = spec->autocfg.hp_pins[i];
1064		if (!nid)
1065			break;
1066		snd_hda_input_jack_report(codec, nid);
1067		spec->jack_present |= snd_hda_jack_detect(codec, nid);
1068	}
1069
1070	mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1071	/* Toggle internal speakers muting */
1072	for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1073		nid = spec->autocfg.speaker_pins[i];
1074		if (!nid)
1075			break;
1076		if (pinctl) {
1077			snd_hda_codec_write(codec, nid, 0,
1078				    AC_VERB_SET_PIN_WIDGET_CONTROL,
1079				    spec->jack_present ? 0 : PIN_OUT);
1080		} else {
1081			snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1082					 HDA_AMP_MUTE, mute);
1083		}
1084	}
1085}
1086
1087static void alc_automute_pin(struct hda_codec *codec)
1088{
1089	alc_automute_speaker(codec, 1);
1090}
1091
1092static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1093				hda_nid_t nid)
1094{
1095	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1096	int i, nums;
1097
1098	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1099	for (i = 0; i < nums; i++)
1100		if (conn[i] == nid)
1101			return i;
1102	return -1;
1103}
1104
1105/* switch the current ADC according to the jack state */
1106static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1107{
1108	struct alc_spec *spec = codec->spec;
1109	unsigned int present;
1110	hda_nid_t new_adc;
1111
1112	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1113	if (present)
1114		spec->cur_adc_idx = 1;
1115	else
1116		spec->cur_adc_idx = 0;
1117	new_adc = spec->adc_nids[spec->cur_adc_idx];
1118	if (spec->cur_adc && spec->cur_adc != new_adc) {
1119		/* stream is running, let's swap the current ADC */
1120		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1121		spec->cur_adc = new_adc;
1122		snd_hda_codec_setup_stream(codec, new_adc,
1123					   spec->cur_adc_stream_tag, 0,
1124					   spec->cur_adc_format);
1125	}
1126}
1127
1128static void alc_mic_automute(struct hda_codec *codec)
1129{
1130	struct alc_spec *spec = codec->spec;
1131	struct alc_mic_route *dead, *alive;
1132	unsigned int present, type;
1133	hda_nid_t cap_nid;
1134
1135	if (!spec->auto_mic)
1136		return;
1137	if (!spec->int_mic.pin || !spec->ext_mic.pin)
1138		return;
1139	if (snd_BUG_ON(!spec->adc_nids))
1140		return;
1141
1142	if (spec->dual_adc_switch) {
1143		alc_dual_mic_adc_auto_switch(codec);
1144		return;
1145	}
1146
1147	cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1148
1149	present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1150	if (present) {
1151		alive = &spec->ext_mic;
1152		dead = &spec->int_mic;
1153	} else {
1154		alive = &spec->int_mic;
1155		dead = &spec->ext_mic;
1156	}
1157
1158	type = get_wcaps_type(get_wcaps(codec, cap_nid));
1159	if (type == AC_WID_AUD_MIX) {
1160		/* Matrix-mixer style (e.g. ALC882) */
1161		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1162					 alive->mux_idx,
1163					 HDA_AMP_MUTE, 0);
1164		snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1165					 dead->mux_idx,
1166					 HDA_AMP_MUTE, HDA_AMP_MUTE);
1167	} else {
1168		/* MUX style (e.g. ALC880) */
1169		snd_hda_codec_write_cache(codec, cap_nid, 0,
1170					  AC_VERB_SET_CONNECT_SEL,
1171					  alive->mux_idx);
1172	}
1173	snd_hda_input_jack_report(codec, spec->ext_mic.pin);
1174
1175	/* FIXME: analog mixer */
1176}
1177
1178/* unsolicited event for HP jack sensing */
1179static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1180{
1181	if (codec->vendor_id == 0x10ec0880)
1182		res >>= 28;
1183	else
1184		res >>= 26;
1185	switch (res) {
1186	case ALC880_HP_EVENT:
1187		alc_automute_pin(codec);
1188		break;
1189	case ALC880_MIC_EVENT:
1190		alc_mic_automute(codec);
1191		break;
1192	}
1193}
1194
1195static void alc_inithook(struct hda_codec *codec)
1196{
1197	alc_automute_pin(codec);
1198	alc_mic_automute(codec);
1199}
1200
1201/* additional initialization for ALC888 variants */
1202static void alc888_coef_init(struct hda_codec *codec)
1203{
1204	unsigned int tmp;
1205
1206	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1207	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1208	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1209	if ((tmp & 0xf0) == 0x20)
1210		/* alc888S-VC */
1211		snd_hda_codec_read(codec, 0x20, 0,
1212				   AC_VERB_SET_PROC_COEF, 0x830);
1213	 else
1214		 /* alc888-VB */
1215		 snd_hda_codec_read(codec, 0x20, 0,
1216				    AC_VERB_SET_PROC_COEF, 0x3030);
1217}
1218
1219static void alc889_coef_init(struct hda_codec *codec)
1220{
1221	unsigned int tmp;
1222
1223	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1224	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1225	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1226	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1227}
1228
1229/* turn on/off EAPD control (only if available) */
1230static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1231{
1232	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1233		return;
1234	if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1235		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1236				    on ? 2 : 0);
1237}
1238
1239static void alc_auto_init_amp(struct hda_codec *codec, int type)
1240{
1241	unsigned int tmp;
1242
1243	switch (type) {
1244	case ALC_INIT_GPIO1:
1245		snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1246		break;
1247	case ALC_INIT_GPIO2:
1248		snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1249		break;
1250	case ALC_INIT_GPIO3:
1251		snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1252		break;
1253	case ALC_INIT_DEFAULT:
1254		switch (codec->vendor_id) {
1255		case 0x10ec0260:
1256			set_eapd(codec, 0x0f, 1);
1257			set_eapd(codec, 0x10, 1);
1258			break;
1259		case 0x10ec0262:
1260		case 0x10ec0267:
1261		case 0x10ec0268:
1262		case 0x10ec0269:
1263		case 0x10ec0270:
1264		case 0x10ec0272:
1265		case 0x10ec0660:
1266		case 0x10ec0662:
1267		case 0x10ec0663:
1268		case 0x10ec0862:
1269		case 0x10ec0889:
1270			set_eapd(codec, 0x14, 1);
1271			set_eapd(codec, 0x15, 1);
1272			break;
1273		}
1274		switch (codec->vendor_id) {
1275		case 0x10ec0260:
1276			snd_hda_codec_write(codec, 0x1a, 0,
1277					    AC_VERB_SET_COEF_INDEX, 7);
1278			tmp = snd_hda_codec_read(codec, 0x1a, 0,
1279						 AC_VERB_GET_PROC_COEF, 0);
1280			snd_hda_codec_write(codec, 0x1a, 0,
1281					    AC_VERB_SET_COEF_INDEX, 7);
1282			snd_hda_codec_write(codec, 0x1a, 0,
1283					    AC_VERB_SET_PROC_COEF,
1284					    tmp | 0x2010);
1285			break;
1286		case 0x10ec0262:
1287		case 0x10ec0880:
1288		case 0x10ec0882:
1289		case 0x10ec0883:
1290		case 0x10ec0885:
1291		case 0x10ec0887:
1292		case 0x10ec0889:
1293			alc889_coef_init(codec);
1294			break;
1295		case 0x10ec0888:
1296			alc888_coef_init(codec);
1297			break;
1298#if 0 /* XXX: This may cause the silent output on speaker on some machines */
1299		case 0x10ec0267:
1300		case 0x10ec0268:
1301			snd_hda_codec_write(codec, 0x20, 0,
1302					    AC_VERB_SET_COEF_INDEX, 7);
1303			tmp = snd_hda_codec_read(codec, 0x20, 0,
1304						 AC_VERB_GET_PROC_COEF, 0);
1305			snd_hda_codec_write(codec, 0x20, 0,
1306					    AC_VERB_SET_COEF_INDEX, 7);
1307			snd_hda_codec_write(codec, 0x20, 0,
1308					    AC_VERB_SET_PROC_COEF,
1309					    tmp | 0x3000);
1310			break;
1311#endif /* XXX */
1312		}
1313		break;
1314	}
1315}
1316
1317static void alc_init_auto_hp(struct hda_codec *codec)
1318{
1319	struct alc_spec *spec = codec->spec;
1320	struct auto_pin_cfg *cfg = &spec->autocfg;
1321	int i;
1322
1323	if (!cfg->hp_pins[0]) {
1324		if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1325			return;
1326	}
1327
1328	if (!cfg->speaker_pins[0]) {
1329		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1330			return;
1331		memcpy(cfg->speaker_pins, cfg->line_out_pins,
1332		       sizeof(cfg->speaker_pins));
1333		cfg->speaker_outs = cfg->line_outs;
1334	}
1335
1336	if (!cfg->hp_pins[0]) {
1337		memcpy(cfg->hp_pins, cfg->line_out_pins,
1338		       sizeof(cfg->hp_pins));
1339		cfg->hp_outs = cfg->line_outs;
1340	}
1341
1342	for (i = 0; i < cfg->hp_outs; i++) {
1343		snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1344			    cfg->hp_pins[i]);
1345		snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1346				  AC_VERB_SET_UNSOLICITED_ENABLE,
1347				  AC_USRSP_EN | ALC880_HP_EVENT);
1348	}
1349	spec->unsol_event = alc_sku_unsol_event;
1350}
1351
1352static void alc_init_auto_mic(struct hda_codec *codec)
1353{
1354	struct alc_spec *spec = codec->spec;
1355	struct auto_pin_cfg *cfg = &spec->autocfg;
1356	hda_nid_t fixed, ext;
1357	int i;
1358
1359	/* there must be only two mic inputs exclusively */
1360	for (i = 0; i < cfg->num_inputs; i++)
1361		if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
1362			return;
1363
1364	fixed = ext = 0;
1365	for (i = 0; i < cfg->num_inputs; i++) {
1366		hda_nid_t nid = cfg->inputs[i].pin;
1367		unsigned int defcfg;
1368		defcfg = snd_hda_codec_get_pincfg(codec, nid);
1369		switch (snd_hda_get_input_pin_attr(defcfg)) {
1370		case INPUT_PIN_ATTR_INT:
1371			if (fixed)
1372				return; /* already occupied */
1373			fixed = nid;
1374			break;
1375		case INPUT_PIN_ATTR_UNUSED:
1376			return; /* invalid entry */
1377		default:
1378			if (ext)
1379				return; /* already occupied */
1380			ext = nid;
1381			break;
1382		}
1383	}
1384	if (!ext || !fixed)
1385		return;
1386	if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1387		return; /* no unsol support */
1388	snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1389		    ext, fixed);
1390	spec->ext_mic.pin = ext;
1391	spec->int_mic.pin = fixed;
1392	spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1393	spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1394	spec->auto_mic = 1;
1395	snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1396				  AC_VERB_SET_UNSOLICITED_ENABLE,
1397				  AC_USRSP_EN | ALC880_MIC_EVENT);
1398	spec->unsol_event = alc_sku_unsol_event;
1399}
1400
1401/* Could be any non-zero and even value. When used as fixup, tells
1402 * the driver to ignore any present sku defines.
1403 */
1404#define ALC_FIXUP_SKU_IGNORE (2)
1405
1406static int alc_auto_parse_customize_define(struct hda_codec *codec)
1407{
1408	unsigned int ass, tmp, i;
1409	unsigned nid = 0;
1410	struct alc_spec *spec = codec->spec;
1411
1412	spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1413
1414	if (spec->cdefine.fixup) {
1415		ass = spec->cdefine.sku_cfg;
1416		if (ass == ALC_FIXUP_SKU_IGNORE)
1417			return -1;
1418		goto do_sku;
1419	}
1420
1421	ass = codec->subsystem_id & 0xffff;
1422	if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1423		goto do_sku;
1424
1425	nid = 0x1d;
1426	if (codec->vendor_id == 0x10ec0260)
1427		nid = 0x17;
1428	ass = snd_hda_codec_get_pincfg(codec, nid);
1429
1430	if (!(ass & 1)) {
1431		printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1432		       codec->chip_name, ass);
1433		return -1;
1434	}
1435
1436	/* check sum */
1437	tmp = 0;
1438	for (i = 1; i < 16; i++) {
1439		if ((ass >> i) & 1)
1440			tmp++;
1441	}
1442	if (((ass >> 16) & 0xf) != tmp)
1443		return -1;
1444
1445	spec->cdefine.port_connectivity = ass >> 30;
1446	spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1447	spec->cdefine.check_sum = (ass >> 16) & 0xf;
1448	spec->cdefine.customization = ass >> 8;
1449do_sku:
1450	spec->cdefine.sku_cfg = ass;
1451	spec->cdefine.external_amp = (ass & 0x38) >> 3;
1452	spec->cdefine.platform_type = (ass & 0x4) >> 2;
1453	spec->cdefine.swap = (ass & 0x2) >> 1;
1454	spec->cdefine.override = ass & 0x1;
1455
1456	snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1457		   nid, spec->cdefine.sku_cfg);
1458	snd_printd("SKU: port_connectivity=0x%x\n",
1459		   spec->cdefine.port_connectivity);
1460	snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1461	snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1462	snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1463	snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1464	snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1465	snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1466	snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1467
1468	return 0;
1469}
1470
1471/* check subsystem ID and set up device-specific initialization;
1472 * return 1 if initialized, 0 if invalid SSID
1473 */
1474/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1475 *	31 ~ 16 :	Manufacture ID
1476 *	15 ~ 8	:	SKU ID
1477 *	7  ~ 0	:	Assembly ID
1478 *	port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1479 */
1480static int alc_subsystem_id(struct hda_codec *codec,
1481			    hda_nid_t porta, hda_nid_t porte,
1482			    hda_nid_t portd, hda_nid_t porti)
1483{
1484	unsigned int ass, tmp, i;
1485	unsigned nid;
1486	struct alc_spec *spec = codec->spec;
1487
1488	if (spec->cdefine.fixup) {
1489		ass = spec->cdefine.sku_cfg;
1490		if (ass == ALC_FIXUP_SKU_IGNORE)
1491			return 0;
1492		goto do_sku;
1493	}
1494
1495	ass = codec->subsystem_id & 0xffff;
1496	if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1497		goto do_sku;
1498
1499	/* invalid SSID, check the special NID pin defcfg instead */
1500	/*
1501	 * 31~30	: port connectivity
1502	 * 29~21	: reserve
1503	 * 20		: PCBEEP input
1504	 * 19~16	: Check sum (15:1)
1505	 * 15~1		: Custom
1506	 * 0		: override
1507	*/
1508	nid = 0x1d;
1509	if (codec->vendor_id == 0x10ec0260)
1510		nid = 0x17;
1511	ass = snd_hda_codec_get_pincfg(codec, nid);
1512	snd_printd("realtek: No valid SSID, "
1513		   "checking pincfg 0x%08x for NID 0x%x\n",
1514		   ass, nid);
1515	if (!(ass & 1))
1516		return 0;
1517	if ((ass >> 30) != 1)	/* no physical connection */
1518		return 0;
1519
1520	/* check sum */
1521	tmp = 0;
1522	for (i = 1; i < 16; i++) {
1523		if ((ass >> i) & 1)
1524			tmp++;
1525	}
1526	if (((ass >> 16) & 0xf) != tmp)
1527		return 0;
1528do_sku:
1529	snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1530		   ass & 0xffff, codec->vendor_id);
1531	/*
1532	 * 0 : override
1533	 * 1 :	Swap Jack
1534	 * 2 : 0 --> Desktop, 1 --> Laptop
1535	 * 3~5 : External Amplifier control
1536	 * 7~6 : Reserved
1537	*/
1538	tmp = (ass & 0x38) >> 3;	/* external Amp control */
1539	switch (tmp) {
1540	case 1:
1541		spec->init_amp = ALC_INIT_GPIO1;
1542		break;
1543	case 3:
1544		spec->init_amp = ALC_INIT_GPIO2;
1545		break;
1546	case 7:
1547		spec->init_amp = ALC_INIT_GPIO3;
1548		break;
1549	case 5:
1550	default:
1551		spec->init_amp = ALC_INIT_DEFAULT;
1552		break;
1553	}
1554
1555	/* is laptop or Desktop and enable the function "Mute internal speaker
1556	 * when the external headphone out jack is plugged"
1557	 */
1558	if (!(ass & 0x8000))
1559		return 1;
1560	/*
1561	 * 10~8 : Jack location
1562	 * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1563	 * 14~13: Resvered
1564	 * 15   : 1 --> enable the function "Mute internal speaker
1565	 *	        when the external headphone out jack is plugged"
1566	 */
1567	if (!spec->autocfg.hp_pins[0]) {
1568		hda_nid_t nid;
1569		tmp = (ass >> 11) & 0x3;	/* HP to chassis */
1570		if (tmp == 0)
1571			nid = porta;
1572		else if (tmp == 1)
1573			nid = porte;
1574		else if (tmp == 2)
1575			nid = portd;
1576		else if (tmp == 3)
1577			nid = porti;
1578		else
1579			return 1;
1580		for (i = 0; i < spec->autocfg.line_outs; i++)
1581			if (spec->autocfg.line_out_pins[i] == nid)
1582				return 1;
1583		spec->autocfg.hp_pins[0] = nid;
1584	}
1585
1586	alc_init_auto_hp(codec);
1587	alc_init_auto_mic(codec);
1588	return 1;
1589}
1590
1591static void alc_ssid_check(struct hda_codec *codec,
1592			   hda_nid_t porta, hda_nid_t porte,
1593			   hda_nid_t portd, hda_nid_t porti)
1594{
1595	if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1596		struct alc_spec *spec = codec->spec;
1597		snd_printd("realtek: "
1598			   "Enable default setup for auto mode as fallback\n");
1599		spec->init_amp = ALC_INIT_DEFAULT;
1600		alc_init_auto_hp(codec);
1601		alc_init_auto_mic(codec);
1602	}
1603}
1604
1605/*
1606 * Fix-up pin default configurations and add default verbs
1607 */
1608
1609struct alc_pincfg {
1610	hda_nid_t nid;
1611	u32 val;
1612};
1613
1614struct alc_model_fixup {
1615	const int id;
1616	const char *name;
1617};
1618
1619struct alc_fixup {
1620	int type;
1621	bool chained;
1622	int chain_id;
1623	union {
1624		unsigned int sku;
1625		const struct alc_pincfg *pins;
1626		const struct hda_verb *verbs;
1627		void (*func)(struct hda_codec *codec,
1628			     const struct alc_fixup *fix,
1629			     int action);
1630	} v;
1631};
1632
1633enum {
1634	ALC_FIXUP_INVALID,
1635	ALC_FIXUP_SKU,
1636	ALC_FIXUP_PINS,
1637	ALC_FIXUP_VERBS,
1638	ALC_FIXUP_FUNC,
1639};
1640
1641enum {
1642	ALC_FIXUP_ACT_PRE_PROBE,
1643	ALC_FIXUP_ACT_PROBE,
1644	ALC_FIXUP_ACT_INIT,
1645};
1646
1647static void alc_apply_fixup(struct hda_codec *codec, int action)
1648{
1649	struct alc_spec *spec = codec->spec;
1650	int id = spec->fixup_id;
1651#ifdef CONFIG_SND_DEBUG_VERBOSE
1652	const char *modelname = spec->fixup_name;
1653#endif
1654	int depth = 0;
1655
1656	if (!spec->fixup_list)
1657		return;
1658
1659	while (id >= 0) {
1660		const struct alc_fixup *fix = spec->fixup_list + id;
1661		const struct alc_pincfg *cfg;
1662
1663		switch (fix->type) {
1664		case ALC_FIXUP_SKU:
1665			if (action != ALC_FIXUP_ACT_PRE_PROBE || !fix->v.sku)
1666				break;;
1667			snd_printdd(KERN_INFO "hda_codec: %s: "
1668				    "Apply sku override for %s\n",
1669				    codec->chip_name, modelname);
1670			spec->cdefine.sku_cfg = fix->v.sku;
1671			spec->cdefine.fixup = 1;
1672			break;
1673		case ALC_FIXUP_PINS:
1674			cfg = fix->v.pins;
1675			if (action != ALC_FIXUP_ACT_PRE_PROBE || !cfg)
1676				break;
1677			snd_printdd(KERN_INFO "hda_codec: %s: "
1678				    "Apply pincfg for %s\n",
1679				    codec->chip_name, modelname);
1680			for (; cfg->nid; cfg++)
1681				snd_hda_codec_set_pincfg(codec, cfg->nid,
1682							 cfg->val);
1683			break;
1684		case ALC_FIXUP_VERBS:
1685			if (action != ALC_FIXUP_ACT_PROBE || !fix->v.verbs)
1686				break;
1687			snd_printdd(KERN_INFO "hda_codec: %s: "
1688				    "Apply fix-verbs for %s\n",
1689				    codec->chip_name, modelname);
1690			add_verb(codec->spec, fix->v.verbs);
1691			break;
1692		case ALC_FIXUP_FUNC:
1693			if (!fix->v.func)
1694				break;
1695			snd_printdd(KERN_INFO "hda_codec: %s: "
1696				    "Apply fix-func for %s\n",
1697				    codec->chip_name, modelname);
1698			fix->v.func(codec, fix, action);
1699			break;
1700		default:
1701			snd_printk(KERN_ERR "hda_codec: %s: "
1702				   "Invalid fixup type %d\n",
1703				   codec->chip_name, fix->type);
1704			break;
1705		}
1706		if (!fix[id].chained)
1707			break;
1708		if (++depth > 10)
1709			break;
1710		id = fix[id].chain_id;
1711	}
1712}
1713
1714static void alc_pick_fixup(struct hda_codec *codec,
1715			   const struct alc_model_fixup *models,
1716			   const struct snd_pci_quirk *quirk,
1717			   const struct alc_fixup *fixlist)
1718{
1719	struct alc_spec *spec = codec->spec;
1720	int id = -1;
1721	const char *name = NULL;
1722
1723	if (codec->modelname && models) {
1724		while (models->name) {
1725			if (!strcmp(codec->modelname, models->name)) {
1726				id = models->id;
1727				name = models->name;
1728				break;
1729			}
1730			models++;
1731		}
1732	}
1733	if (id < 0) {
1734		quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1735		if (quirk) {
1736			id = quirk->value;
1737#ifdef CONFIG_SND_DEBUG_VERBOSE
1738			name = quirk->name;
1739#endif
1740		}
1741	}
1742
1743	spec->fixup_id = id;
1744	if (id >= 0) {
1745		spec->fixup_list = fixlist;
1746		spec->fixup_name = name;
1747	}
1748}
1749
1750static int alc_read_coef_idx(struct hda_codec *codec,
1751			unsigned int coef_idx)
1752{
1753	unsigned int val;
1754	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1755		    		coef_idx);
1756	val = snd_hda_codec_read(codec, 0x20, 0,
1757			 	AC_VERB_GET_PROC_COEF, 0);
1758	return val;
1759}
1760
1761static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx,
1762							unsigned int coef_val)
1763{
1764	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1765			    coef_idx);
1766	snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF,
1767			    coef_val);
1768}
1769
1770/* set right pin controls for digital I/O */
1771static void alc_auto_init_digital(struct hda_codec *codec)
1772{
1773	struct alc_spec *spec = codec->spec;
1774	int i;
1775	hda_nid_t pin;
1776
1777	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1778		pin = spec->autocfg.dig_out_pins[i];
1779		if (pin) {
1780			snd_hda_codec_write(codec, pin, 0,
1781					    AC_VERB_SET_PIN_WIDGET_CONTROL,
1782					    PIN_OUT);
1783		}
1784	}
1785	pin = spec->autocfg.dig_in_pin;
1786	if (pin)
1787		snd_hda_codec_write(codec, pin, 0,
1788				    AC_VERB_SET_PIN_WIDGET_CONTROL,
1789				    PIN_IN);
1790}
1791
1792/* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1793static void alc_auto_parse_digital(struct hda_codec *codec)
1794{
1795	struct alc_spec *spec = codec->spec;
1796	int i, err;
1797	hda_nid_t dig_nid;
1798
1799	/* support multiple SPDIFs; the secondary is set up as a slave */
1800	for (i = 0; i < spec->autocfg.dig_outs; i++) {
1801		err = snd_hda_get_connections(codec,
1802					      spec->autocfg.dig_out_pins[i],
1803					      &dig_nid, 1);
1804		if (err < 0)
1805			continue;
1806		if (!i) {
1807			spec->multiout.dig_out_nid = dig_nid;
1808			spec->dig_out_type = spec->autocfg.dig_out_type[0];
1809		} else {
1810			spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1811			if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1812				break;
1813			spec->slave_dig_outs[i - 1] = dig_nid;
1814		}
1815	}
1816
1817	if (spec->autocfg.dig_in_pin) {
1818		dig_nid = codec->start_nid;
1819		for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
1820			unsigned int wcaps = get_wcaps(codec, dig_nid);
1821			if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
1822				continue;
1823			if (!(wcaps & AC_WCAP_DIGITAL))
1824				continue;
1825			if (!(wcaps & AC_WCAP_CONN_LIST))
1826				continue;
1827			err = get_connection_index(codec, dig_nid,
1828						   spec->autocfg.dig_in_pin);
1829			if (err >= 0) {
1830				spec->dig_in_nid = dig_nid;
1831				break;
1832			}
1833		}
1834	}
1835}
1836
1837/*
1838 * ALC888
1839 */
1840
1841/*
1842 * 2ch mode
1843 */
1844static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1845/* Mic-in jack as mic in */
1846	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1847	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1848/* Line-in jack as Line in */
1849	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1850	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1851/* Line-Out as Front */
1852	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1853	{ } /* end */
1854};
1855
1856/*
1857 * 4ch mode
1858 */
1859static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1860/* Mic-in jack as mic in */
1861	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1862	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1863/* Line-in jack as Surround */
1864	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1865	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1866/* Line-Out as Front */
1867	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1868	{ } /* end */
1869};
1870
1871/*
1872 * 6ch mode
1873 */
1874static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1875/* Mic-in jack as CLFE */
1876	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1877	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1878/* Line-in jack as Surround */
1879	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1880	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1881/* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1882	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1883	{ } /* end */
1884};
1885
1886/*
1887 * 8ch mode
1888 */
1889static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1890/* Mic-in jack as CLFE */
1891	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1892	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1893/* Line-in jack as Surround */
1894	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1895	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1896/* Line-Out as Side */
1897	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1898	{ } /* end */
1899};
1900
1901static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1902	{ 2, alc888_4ST_ch2_intel_init },
1903	{ 4, alc888_4ST_ch4_intel_init },
1904	{ 6, alc888_4ST_ch6_intel_init },
1905	{ 8, alc888_4ST_ch8_intel_init },
1906};
1907
1908/*
1909 * ALC888 Fujitsu Siemens Amillo xa3530
1910 */
1911
1912static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1913/* Front Mic: set to PIN_IN (empty by default) */
1914	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1915/* Connect Internal HP to Front */
1916	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1917	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1918	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1919/* Connect Bass HP to Front */
1920	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1921	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1922	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1923/* Connect Line-Out side jack (SPDIF) to Side */
1924	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1925	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1926	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1927/* Connect Mic jack to CLFE */
1928	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1929	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1930	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1931/* Connect Line-in jack to Surround */
1932	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1933	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1934	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1935/* Connect HP out jack to Front */
1936	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1937	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1938	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1939/* Enable unsolicited event for HP jack and Line-out jack */
1940	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1941	{0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1942	{}
1943};
1944
1945static void alc_automute_amp(struct hda_codec *codec)
1946{
1947	alc_automute_speaker(codec, 0);
1948}
1949
1950static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1951					 unsigned int res)
1952{
1953	if (codec->vendor_id == 0x10ec0880)
1954		res >>= 28;
1955	else
1956		res >>= 26;
1957	if (res == ALC880_HP_EVENT)
1958		alc_automute_amp(codec);
1959}
1960
1961static void alc889_automute_setup(struct hda_codec *codec)
1962{
1963	struct alc_spec *spec = codec->spec;
1964
1965	spec->autocfg.hp_pins[0] = 0x15;
1966	spec->autocfg.speaker_pins[0] = 0x14;
1967	spec->autocfg.speaker_pins[1] = 0x16;
1968	spec->autocfg.speaker_pins[2] = 0x17;
1969	spec->autocfg.speaker_pins[3] = 0x19;
1970	spec->autocfg.speaker_pins[4] = 0x1a;
1971}
1972
1973static void alc889_intel_init_hook(struct hda_codec *codec)
1974{
1975	alc889_coef_init(codec);
1976	alc_automute_amp(codec);
1977}
1978
1979static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1980{
1981	struct alc_spec *spec = codec->spec;
1982
1983	spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1984	spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1985	spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1986	spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1987}
1988
1989/*
1990 * ALC888 Acer Aspire 4930G model
1991 */
1992
1993static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1994/* Front Mic: set to PIN_IN (empty by default) */
1995	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1996/* Unselect Front Mic by default in input mixer 3 */
1997	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1998/* Enable unsolicited event for HP jack */
1999	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2000/* Connect Internal HP to front */
2001	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2002	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2003	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2004/* Connect HP out to front */
2005	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2006	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2007	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2008	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2009	{ }
2010};
2011
2012/*
2013 * ALC888 Acer Aspire 6530G model
2014 */
2015
2016static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
2017/* Route to built-in subwoofer as well as speakers */
2018	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2019	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2020	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2021	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
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	{ }
2040};
2041
2042/*
2043 *ALC888 Acer Aspire 7730G model
2044 */
2045
2046static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
2047/* Bias voltage on for external mic port */
2048	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
2049/* Front Mic: set to PIN_IN (empty by default) */
2050	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2051/* Unselect Front Mic by default in input mixer 3 */
2052	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2053/* Enable unsolicited event for HP jack */
2054	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2055/* Enable speaker output */
2056	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2057	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2058	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
2059/* Enable headphone output */
2060	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2061	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2062	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2063	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
2064/*Enable internal subwoofer */
2065	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2066	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2067	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
2068	{0x17, AC_VERB_SET_EAPD_BTLENABLE, 2},
2069	{ }
2070};
2071
2072/*
2073 * ALC889 Acer Aspire 8930G model
2074 */
2075
2076static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
2077/* Front Mic: set to PIN_IN (empty by default) */
2078	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2079/* Unselect Front Mic by default in input mixer 3 */
2080	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
2081/* Enable unsolicited event for HP jack */
2082	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
2083/* Connect Internal Front to Front */
2084	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2085	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2086	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
2087/* Connect Internal Rear to Rear */
2088	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2089	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2090	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
2091/* Connect Internal CLFE to CLFE */
2092	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2093	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2094	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
2095/* Connect HP out to Front */
2096	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
2097	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2098	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
2099/* Enable all DACs */
2100/*  DAC DISABLE/MUTE 1? */
2101/*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
2102	{0x20, AC_VERB_SET_COEF_INDEX, 0x03},
2103	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2104/*  DAC DISABLE/MUTE 2? */
2105/*  some bit here disables the other DACs. Init=0x4900 */
2106	{0x20, AC_VERB_SET_COEF_INDEX, 0x08},
2107	{0x20, AC_VERB_SET_PROC_COEF, 0x0000},
2108/* DMIC fix
2109 * This laptop has a stereo digital microphone. The mics are only 1cm apart
2110 * which makes the stereo useless. However, either the mic or the ALC889
2111 * makes the signal become a difference/sum signal instead of standard
2112 * stereo, which is annoying. So instead we flip this bit which makes the
2113 * codec replicate the sum signal to both channels, turning it into a
2114 * normal mono mic.
2115 */
2116/*  DMIC_CONTROL? Init value = 0x0001 */
2117	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
2118	{0x20, AC_VERB_SET_PROC_COEF, 0x0003},
2119	{ }
2120};
2121
2122static struct hda_input_mux alc888_2_capture_sources[2] = {
2123	/* Front mic only available on one ADC */
2124	{
2125		.num_items = 4,
2126		.items = {
2127			{ "Mic", 0x0 },
2128			{ "Line", 0x2 },
2129			{ "CD", 0x4 },
2130			{ "Front Mic", 0xb },
2131		},
2132	},
2133	{
2134		.num_items = 3,
2135		.items = {
2136			{ "Mic", 0x0 },
2137			{ "Line", 0x2 },
2138			{ "CD", 0x4 },
2139		},
2140	}
2141};
2142
2143static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
2144	/* Interal mic only available on one ADC */
2145	{
2146		.num_items = 5,
2147		.items = {
2148			{ "Mic", 0x0 },
2149			{ "Line In", 0x2 },
2150			{ "CD", 0x4 },
2151			{ "Input Mix", 0xa },
2152			{ "Internal Mic", 0xb },
2153		},
2154	},
2155	{
2156		.num_items = 4,
2157		.items = {
2158			{ "Mic", 0x0 },
2159			{ "Line In", 0x2 },
2160			{ "CD", 0x4 },
2161			{ "Input Mix", 0xa },
2162		},
2163	}
2164};
2165
2166static struct hda_input_mux alc889_capture_sources[3] = {
2167	/* Digital mic only available on first "ADC" */
2168	{
2169		.num_items = 5,
2170		.items = {
2171			{ "Mic", 0x0 },
2172			{ "Line", 0x2 },
2173			{ "CD", 0x4 },
2174			{ "Front Mic", 0xb },
2175			{ "Input Mix", 0xa },
2176		},
2177	},
2178	{
2179		.num_items = 4,
2180		.items = {
2181			{ "Mic", 0x0 },
2182			{ "Line", 0x2 },
2183			{ "CD", 0x4 },
2184			{ "Input Mix", 0xa },
2185		},
2186	},
2187	{
2188		.num_items = 4,
2189		.items = {
2190			{ "Mic", 0x0 },
2191			{ "Line", 0x2 },
2192			{ "CD", 0x4 },
2193			{ "Input Mix", 0xa },
2194		},
2195	}
2196};
2197
2198static struct snd_kcontrol_new alc888_base_mixer[] = {
2199	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2200	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2201	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2202	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2203	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2204		HDA_OUTPUT),
2205	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2206	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2207	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2208	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2209	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2210	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2211	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2212	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2213	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2214	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2215	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2216	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2217	{ } /* end */
2218};
2219
2220static struct snd_kcontrol_new alc888_acer_aspire_4930g_mixer[] = {
2221	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2222	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2223	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2224	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2225	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2226		HDA_OUTPUT),
2227	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2228	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2229	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2230	HDA_CODEC_VOLUME_MONO("Internal LFE Playback Volume", 0x0f, 1, 0x0, HDA_OUTPUT),
2231	HDA_BIND_MUTE_MONO("Internal LFE Playback Switch", 0x0f, 1, 2, HDA_INPUT),
2232	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2233	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2234	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2235	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2236	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2237	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2238	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2239	{ } /* end */
2240};
2241
2242static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
2243	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2244	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2245	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2246	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2247	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
2248		HDA_OUTPUT),
2249	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2250	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2251	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2252	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2253	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2254	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2255	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
2256	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2257	{ } /* end */
2258};
2259
2260
2261static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2262{
2263	struct alc_spec *spec = codec->spec;
2264
2265	spec->autocfg.hp_pins[0] = 0x15;
2266	spec->autocfg.speaker_pins[0] = 0x14;
2267	spec->autocfg.speaker_pins[1] = 0x16;
2268	spec->autocfg.speaker_pins[2] = 0x17;
2269}
2270
2271static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2272{
2273	struct alc_spec *spec = codec->spec;
2274
2275	spec->autocfg.hp_pins[0] = 0x15;
2276	spec->autocfg.speaker_pins[0] = 0x14;
2277	spec->autocfg.speaker_pins[1] = 0x16;
2278	spec->autocfg.speaker_pins[2] = 0x17;
2279}
2280
2281static void alc888_acer_aspire_7730g_setup(struct hda_codec *codec)
2282{
2283	struct alc_spec *spec = codec->spec;
2284
2285	spec->autocfg.hp_pins[0] = 0x15;
2286	spec->autocfg.speaker_pins[0] = 0x14;
2287	spec->autocfg.speaker_pins[1] = 0x16;
2288	spec->autocfg.speaker_pins[2] = 0x17;
2289}
2290
2291static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2292{
2293	struct alc_spec *spec = codec->spec;
2294
2295	spec->autocfg.hp_pins[0] = 0x15;
2296	spec->autocfg.speaker_pins[0] = 0x14;
2297	spec->autocfg.speaker_pins[1] = 0x16;
2298	spec->autocfg.speaker_pins[2] = 0x1b;
2299}
2300
2301/*
2302 * ALC880 3-stack model
2303 *
2304 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2305 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2306 *                 F-Mic = 0x1b, HP = 0x19
2307 */
2308
2309static hda_nid_t alc880_dac_nids[4] = {
2310	/* front, rear, clfe, rear_surr */
2311	0x02, 0x05, 0x04, 0x03
2312};
2313
2314static hda_nid_t alc880_adc_nids[3] = {
2315	/* ADC0-2 */
2316	0x07, 0x08, 0x09,
2317};
2318
2319/* The datasheet says the node 0x07 is connected from inputs,
2320 * but it shows zero connection in the real implementation on some devices.
2321 * Note: this is a 915GAV bug, fixed on 915GLV
2322 */
2323static hda_nid_t alc880_adc_nids_alt[2] = {
2324	/* ADC1-2 */
2325	0x08, 0x09,
2326};
2327
2328#define ALC880_DIGOUT_NID	0x06
2329#define ALC880_DIGIN_NID	0x0a
2330
2331static struct hda_input_mux alc880_capture_source = {
2332	.num_items = 4,
2333	.items = {
2334		{ "Mic", 0x0 },
2335		{ "Front Mic", 0x3 },
2336		{ "Line", 0x2 },
2337		{ "CD", 0x4 },
2338	},
2339};
2340
2341/* channel source setting (2/6 channel selection for 3-stack) */
2342/* 2ch mode */
2343static struct hda_verb alc880_threestack_ch2_init[] = {
2344	/* set line-in to input, mute it */
2345	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2346	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2347	/* set mic-in to input vref 80%, mute it */
2348	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2349	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2350	{ } /* end */
2351};
2352
2353/* 6ch mode */
2354static struct hda_verb alc880_threestack_ch6_init[] = {
2355	/* set line-in to output, unmute it */
2356	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2357	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2358	/* set mic-in to output, unmute it */
2359	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2360	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2361	{ } /* end */
2362};
2363
2364static struct hda_channel_mode alc880_threestack_modes[2] = {
2365	{ 2, alc880_threestack_ch2_init },
2366	{ 6, alc880_threestack_ch6_init },
2367};
2368
2369static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2370	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2371	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2372	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2373	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2374	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2375	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2376	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2377	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2378	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2379	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2380	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2381	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2382	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2383	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2384	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2385	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2386	HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2387	{
2388		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2389		.name = "Channel Mode",
2390		.info = alc_ch_mode_info,
2391		.get = alc_ch_mode_get,
2392		.put = alc_ch_mode_put,
2393	},
2394	{ } /* end */
2395};
2396
2397/* capture mixer elements */
2398static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2399			    struct snd_ctl_elem_info *uinfo)
2400{
2401	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2402	struct alc_spec *spec = codec->spec;
2403	int err;
2404
2405	mutex_lock(&codec->control_mutex);
2406	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2407						      HDA_INPUT);
2408	err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2409	mutex_unlock(&codec->control_mutex);
2410	return err;
2411}
2412
2413static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2414			   unsigned int size, unsigned int __user *tlv)
2415{
2416	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2417	struct alc_spec *spec = codec->spec;
2418	int err;
2419
2420	mutex_lock(&codec->control_mutex);
2421	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2422						      HDA_INPUT);
2423	err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2424	mutex_unlock(&codec->control_mutex);
2425	return err;
2426}
2427
2428typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2429			     struct snd_ctl_elem_value *ucontrol);
2430
2431static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2432				 struct snd_ctl_elem_value *ucontrol,
2433				 getput_call_t func)
2434{
2435	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2436	struct alc_spec *spec = codec->spec;
2437	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2438	int err;
2439
2440	mutex_lock(&codec->control_mutex);
2441	kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2442						      3, 0, HDA_INPUT);
2443	err = func(kcontrol, ucontrol);
2444	mutex_unlock(&codec->control_mutex);
2445	return err;
2446}
2447
2448static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2449			   struct snd_ctl_elem_value *ucontrol)
2450{
2451	return alc_cap_getput_caller(kcontrol, ucontrol,
2452				     snd_hda_mixer_amp_volume_get);
2453}
2454
2455static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2456			   struct snd_ctl_elem_value *ucontrol)
2457{
2458	return alc_cap_getput_caller(kcontrol, ucontrol,
2459				     snd_hda_mixer_amp_volume_put);
2460}
2461
2462/* capture mixer elements */
2463#define alc_cap_sw_info		snd_ctl_boolean_stereo_info
2464
2465static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2466			  struct snd_ctl_elem_value *ucontrol)
2467{
2468	return alc_cap_getput_caller(kcontrol, ucontrol,
2469				     snd_hda_mixer_amp_switch_get);
2470}
2471
2472static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2473			  struct snd_ctl_elem_value *ucontrol)
2474{
2475	return alc_cap_getput_caller(kcontrol, ucontrol,
2476				     snd_hda_mixer_amp_switch_put);
2477}
2478
2479#define _DEFINE_CAPMIX(num) \
2480	{ \
2481		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2482		.name = "Capture Switch", \
2483		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2484		.count = num, \
2485		.info = alc_cap_sw_info, \
2486		.get = alc_cap_sw_get, \
2487		.put = alc_cap_sw_put, \
2488	}, \
2489	{ \
2490		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2491		.name = "Capture Volume", \
2492		.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2493			   SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2494			   SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2495		.count = num, \
2496		.info = alc_cap_vol_info, \
2497		.get = alc_cap_vol_get, \
2498		.put = alc_cap_vol_put, \
2499		.tlv = { .c = alc_cap_vol_tlv }, \
2500	}
2501
2502#define _DEFINE_CAPSRC(num) \
2503	{ \
2504		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2505		/* .name = "Capture Source", */ \
2506		.name = "Input Source", \
2507		.count = num, \
2508		.info = alc_mux_enum_info, \
2509		.get = alc_mux_enum_get, \
2510		.put = alc_mux_enum_put, \
2511	}
2512
2513#define DEFINE_CAPMIX(num) \
2514static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2515	_DEFINE_CAPMIX(num),				      \
2516	_DEFINE_CAPSRC(num),				      \
2517	{ } /* end */					      \
2518}
2519
2520#define DEFINE_CAPMIX_NOSRC(num) \
2521static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2522	_DEFINE_CAPMIX(num),					    \
2523	{ } /* end */						    \
2524}
2525
2526/* up to three ADCs */
2527DEFINE_CAPMIX(1);
2528DEFINE_CAPMIX(2);
2529DEFINE_CAPMIX(3);
2530DEFINE_CAPMIX_NOSRC(1);
2531DEFINE_CAPMIX_NOSRC(2);
2532DEFINE_CAPMIX_NOSRC(3);
2533
2534/*
2535 * ALC880 5-stack model
2536 *
2537 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2538 *      Side = 0x02 (0xd)
2539 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2540 *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2541 */
2542
2543/* additional mixers to alc880_three_stack_mixer */
2544static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2545	HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2546	HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2547	{ } /* end */
2548};
2549
2550/* channel source setting (6/8 channel selection for 5-stack) */
2551/* 6ch mode */
2552static struct hda_verb alc880_fivestack_ch6_init[] = {
2553	/* set line-in to input, mute it */
2554	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2555	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2556	{ } /* end */
2557};
2558
2559/* 8ch mode */
2560static struct hda_verb alc880_fivestack_ch8_init[] = {
2561	/* set line-in to output, unmute it */
2562	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2563	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2564	{ } /* end */
2565};
2566
2567static struct hda_channel_mode alc880_fivestack_modes[2] = {
2568	{ 6, alc880_fivestack_ch6_init },
2569	{ 8, alc880_fivestack_ch8_init },
2570};
2571
2572
2573/*
2574 * ALC880 6-stack model
2575 *
2576 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2577 *      Side = 0x05 (0x0f)
2578 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2579 *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2580 */
2581
2582static hda_nid_t alc880_6st_dac_nids[4] = {
2583	/* front, rear, clfe, rear_surr */
2584	0x02, 0x03, 0x04, 0x05
2585};
2586
2587static struct hda_input_mux alc880_6stack_capture_source = {
2588	.num_items = 4,
2589	.items = {
2590		{ "Mic", 0x0 },
2591		{ "Front Mic", 0x1 },
2592		{ "Line", 0x2 },
2593		{ "CD", 0x4 },
2594	},
2595};
2596
2597/* fixed 8-channels */
2598static struct hda_channel_mode alc880_sixstack_modes[1] = {
2599	{ 8, NULL },
2600};
2601
2602static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2603	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2604	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2605	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2606	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2607	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2608	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2609	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2610	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2611	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2612	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2613	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2614	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2615	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2616	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2617	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2618	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2619	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2620	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2621	{
2622		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2623		.name = "Channel Mode",
2624		.info = alc_ch_mode_info,
2625		.get = alc_ch_mode_get,
2626		.put = alc_ch_mode_put,
2627	},
2628	{ } /* end */
2629};
2630
2631
2632/*
2633 * ALC880 W810 model
2634 *
2635 * W810 has rear IO for:
2636 * Front (DAC 02)
2637 * Surround (DAC 03)
2638 * Center/LFE (DAC 04)
2639 * Digital out (06)
2640 *
2641 * The system also has a pair of internal speakers, and a headphone jack.
2642 * These are both connected to Line2 on the codec, hence to DAC 02.
2643 *
2644 * There is a variable resistor to control the speaker or headphone
2645 * volume. This is a hardware-only device without a software API.
2646 *
2647 * Plugging headphones in will disable the internal speakers. This is
2648 * implemented in hardware, not via the driver using jack sense. In
2649 * a similar fashion, plugging into the rear socket marked "front" will
2650 * disable both the speakers and headphones.
2651 *
2652 * For input, there's a microphone jack, and an "audio in" jack.
2653 * These may not do anything useful with this driver yet, because I
2654 * haven't setup any initialization verbs for these yet...
2655 */
2656
2657static hda_nid_t alc880_w810_dac_nids[3] = {
2658	/* front, rear/surround, clfe */
2659	0x02, 0x03, 0x04
2660};
2661
2662/* fixed 6 channels */
2663static struct hda_channel_mode alc880_w810_modes[1] = {
2664	{ 6, NULL }
2665};
2666
2667/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2668static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2669	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2670	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2671	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2672	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2673	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2674	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2675	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2676	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2677	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2678	{ } /* end */
2679};
2680
2681
2682/*
2683 * Z710V model
2684 *
2685 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2686 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2687 *                 Line = 0x1a
2688 */
2689
2690static hda_nid_t alc880_z71v_dac_nids[1] = {
2691	0x02
2692};
2693#define ALC880_Z71V_HP_DAC	0x03
2694
2695/* fixed 2 channels */
2696static struct hda_channel_mode alc880_2_jack_modes[1] = {
2697	{ 2, NULL }
2698};
2699
2700static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2701	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2702	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2703	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2704	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2705	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2706	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2707	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2708	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2709	{ } /* end */
2710};
2711
2712
2713/*
2714 * ALC880 F1734 model
2715 *
2716 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2717 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2718 */
2719
2720static hda_nid_t alc880_f1734_dac_nids[1] = {
2721	0x03
2722};
2723#define ALC880_F1734_HP_DAC	0x02
2724
2725static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2726	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2727	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2728	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2729	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2730	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2731	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2732	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2733	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2734	{ } /* end */
2735};
2736
2737static struct hda_input_mux alc880_f1734_capture_source = {
2738	.num_items = 2,
2739	.items = {
2740		{ "Mic", 0x1 },
2741		{ "CD", 0x4 },
2742	},
2743};
2744
2745
2746/*
2747 * ALC880 ASUS model
2748 *
2749 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2750 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2751 *  Mic = 0x18, Line = 0x1a
2752 */
2753
2754#define alc880_asus_dac_nids	alc880_w810_dac_nids	/* identical with w810 */
2755#define alc880_asus_modes	alc880_threestack_modes	/* 2/6 channel mode */
2756
2757static struct snd_kcontrol_new alc880_asus_mixer[] = {
2758	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2759	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2760	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2761	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2762	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2763	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2764	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2765	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2766	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2767	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2768	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2769	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2770	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2771	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2772	{
2773		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2774		.name = "Channel Mode",
2775		.info = alc_ch_mode_info,
2776		.get = alc_ch_mode_get,
2777		.put = alc_ch_mode_put,
2778	},
2779	{ } /* end */
2780};
2781
2782/*
2783 * ALC880 ASUS W1V model
2784 *
2785 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2786 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2787 *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2788 */
2789
2790/* additional mixers to alc880_asus_mixer */
2791static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2792	HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2793	HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2794	{ } /* end */
2795};
2796
2797/* TCL S700 */
2798static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2799	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2800	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2801	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2802	HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2803	HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2804	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2805	HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2806	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2807	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2808	{ } /* end */
2809};
2810
2811/* Uniwill */
2812static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2813	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2814	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2815	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2816	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2817	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2818	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2819	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2820	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2821	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2822	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2823	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2824	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2825	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2826	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2827	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2828	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2829	{
2830		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2831		.name = "Channel Mode",
2832		.info = alc_ch_mode_info,
2833		.get = alc_ch_mode_get,
2834		.put = alc_ch_mode_put,
2835	},
2836	{ } /* end */
2837};
2838
2839static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2840	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2841	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2842	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2843	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2844	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2845	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2846	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2847	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2848	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2849	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2850	{ } /* end */
2851};
2852
2853static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2854	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2855	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2856	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2857	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2858	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2859	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2860	{ } /* end */
2861};
2862
2863/*
2864 * virtual master controls
2865 */
2866
2867/*
2868 * slave controls for virtual master
2869 */
2870static const char * const alc_slave_vols[] = {
2871	"Front Playback Volume",
2872	"Surround Playback Volume",
2873	"Center Playback Volume",
2874	"LFE Playback Volume",
2875	"Side Playback Volume",
2876	"Headphone Playback Volume",
2877	"Speaker Playback Volume",
2878	"Mono Playback Volume",
2879	"Line-Out Playback Volume",
2880	"PCM Playback Volume",
2881	NULL,
2882};
2883
2884static const char * const alc_slave_sws[] = {
2885	"Front Playback Switch",
2886	"Surround Playback Switch",
2887	"Center Playback Switch",
2888	"LFE Playback Switch",
2889	"Side Playback Switch",
2890	"Headphone Playback Switch",
2891	"Speaker Playback Switch",
2892	"Mono Playback Switch",
2893	"IEC958 Playback Switch",
2894	"Line-Out Playback Switch",
2895	"PCM Playback Switch",
2896	NULL,
2897};
2898
2899/*
2900 * build control elements
2901 */
2902
2903#define NID_MAPPING		(-1)
2904
2905#define SUBDEV_SPEAKER_		(0 << 6)
2906#define SUBDEV_HP_		(1 << 6)
2907#define SUBDEV_LINE_		(2 << 6)
2908#define SUBDEV_SPEAKER(x)	(SUBDEV_SPEAKER_ | ((x) & 0x3f))
2909#define SUBDEV_HP(x)		(SUBDEV_HP_ | ((x) & 0x3f))
2910#define SUBDEV_LINE(x)		(SUBDEV_LINE_ | ((x) & 0x3f))
2911
2912static void alc_free_kctls(struct hda_codec *codec);
2913
2914#ifdef CONFIG_SND_HDA_INPUT_BEEP
2915/* additional beep mixers; the actual parameters are overwritten at build */
2916static struct snd_kcontrol_new alc_beep_mixer[] = {
2917	HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2918	HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2919	{ } /* end */
2920};
2921#endif
2922
2923static int alc_build_controls(struct hda_codec *codec)
2924{
2925	struct alc_spec *spec = codec->spec;
2926	struct snd_kcontrol *kctl = NULL;
2927	struct snd_kcontrol_new *knew;
2928	int i, j, err;
2929	unsigned int u;
2930	hda_nid_t nid;
2931
2932	for (i = 0; i < spec->num_mixers; i++) {
2933		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2934		if (err < 0)
2935			return err;
2936	}
2937	if (spec->cap_mixer) {
2938		err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2939		if (err < 0)
2940			return err;
2941	}
2942	if (spec->multiout.dig_out_nid) {
2943		err = snd_hda_create_spdif_out_ctls(codec,
2944						    spec->multiout.dig_out_nid);
2945		if (err < 0)
2946			return err;
2947		if (!spec->no_analog) {
2948			err = snd_hda_create_spdif_share_sw(codec,
2949							    &spec->multiout);
2950			if (err < 0)
2951				return err;
2952			spec->multiout.share_spdif = 1;
2953		}
2954	}
2955	if (spec->dig_in_nid) {
2956		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2957		if (err < 0)
2958			return err;
2959	}
2960
2961#ifdef CONFIG_SND_HDA_INPUT_BEEP
2962	/* create beep controls if needed */
2963	if (spec->beep_amp) {
2964		struct snd_kcontrol_new *knew;
2965		for (knew = alc_beep_mixer; knew->name; knew++) {
2966			struct snd_kcontrol *kctl;
2967			kctl = snd_ctl_new1(knew, codec);
2968			if (!kctl)
2969				return -ENOMEM;
2970			kctl->private_value = spec->beep_amp;
2971			err = snd_hda_ctl_add(codec, 0, kctl);
2972			if (err < 0)
2973				return err;
2974		}
2975	}
2976#endif
2977
2978	/* if we have no master control, let's create it */
2979	if (!spec->no_analog &&
2980	    !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2981		unsigned int vmaster_tlv[4];
2982		snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2983					HDA_OUTPUT, vmaster_tlv);
2984		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2985					  vmaster_tlv, alc_slave_vols);
2986		if (err < 0)
2987			return err;
2988	}
2989	if (!spec->no_analog &&
2990	    !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2991		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2992					  NULL, alc_slave_sws);
2993		if (err < 0)
2994			return err;
2995	}
2996
2997	/* assign Capture Source enums to NID */
2998	if (spec->capsrc_nids || spec->adc_nids) {
2999		kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
3000		if (!kctl)
3001			kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
3002		for (i = 0; kctl && i < kctl->count; i++) {
3003			hda_nid_t *nids = spec->capsrc_nids;
3004			if (!nids)
3005				nids = spec->adc_nids;
3006			err = snd_hda_add_nid(codec, kctl, i, nids[i]);
3007			if (err < 0)
3008				return err;
3009		}
3010	}
3011	if (spec->cap_mixer) {
3012		const char *kname = kctl ? kctl->id.name : NULL;
3013		for (knew = spec->cap_mixer; knew->name; knew++) {
3014			if (kname && strcmp(knew->name, kname) == 0)
3015				continue;
3016			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3017			for (i = 0; kctl && i < kctl->count; i++) {
3018				err = snd_hda_add_nid(codec, kctl, i,
3019						      spec->adc_nids[i]);
3020				if (err < 0)
3021					return err;
3022			}
3023		}
3024	}
3025
3026	/* other nid->control mapping */
3027	for (i = 0; i < spec->num_mixers; i++) {
3028		for (knew = spec->mixers[i]; knew->name; knew++) {
3029			if (knew->iface != NID_MAPPING)
3030				continue;
3031			kctl = snd_hda_find_mixer_ctl(codec, knew->name);
3032			if (kctl == NULL)
3033				continue;
3034			u = knew->subdevice;
3035			for (j = 0; j < 4; j++, u >>= 8) {
3036				nid = u & 0x3f;
3037				if (nid == 0)
3038					continue;
3039				switch (u & 0xc0) {
3040				case SUBDEV_SPEAKER_:
3041					nid = spec->autocfg.speaker_pins[nid];
3042					break;
3043				case SUBDEV_LINE_:
3044					nid = spec->autocfg.line_out_pins[nid];
3045					break;
3046				case SUBDEV_HP_:
3047					nid = spec->autocfg.hp_pins[nid];
3048					break;
3049				default:
3050					continue;
3051				}
3052				err = snd_hda_add_nid(codec, kctl, 0, nid);
3053				if (err < 0)
3054					return err;
3055			}
3056			u = knew->private_value;
3057			for (j = 0; j < 4; j++, u >>= 8) {
3058				nid = u & 0xff;
3059				if (nid == 0)
3060					continue;
3061				err = snd_hda_add_nid(codec, kctl, 0, nid);
3062				if (err < 0)
3063					return err;
3064			}
3065		}
3066	}
3067
3068	alc_free_kctls(codec); /* no longer needed */
3069
3070	return 0;
3071}
3072
3073
3074/*
3075 * initialize the codec volumes, etc
3076 */
3077
3078/*
3079 * generic initialization of ADC, input mixers and output mixers
3080 */
3081static struct hda_verb alc880_volume_init_verbs[] = {
3082	/*
3083	 * Unmute ADC0-2 and set the default input to mic-in
3084	 */
3085	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3086	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3087	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3088	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3089	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3090	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3091
3092	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3093	 * mixer widget
3094	 * Note: PASD motherboards uses the Line In 2 as the input for front
3095	 * panel mic (mic 2)
3096	 */
3097	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
3098	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3099	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3100	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3101	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3102	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3103	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3104	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3105
3106	/*
3107	 * Set up output mixers (0x0c - 0x0f)
3108	 */
3109	/* set vol=0 to output mixers */
3110	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3111	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3112	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3113	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3114	/* set up input amps for analog loopback */
3115	/* Amp Indices: DAC = 0, mixer = 1 */
3116	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3117	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3118	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3119	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3120	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3121	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3122	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3123	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3124
3125	{ }
3126};
3127
3128/*
3129 * 3-stack pin configuration:
3130 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
3131 */
3132static struct hda_verb alc880_pin_3stack_init_verbs[] = {
3133	/*
3134	 * preset connection lists of input pins
3135	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3136	 */
3137	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3138	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3139	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3140
3141	/*
3142	 * Set pin mode and muting
3143	 */
3144	/* set front pin widgets 0x14 for output */
3145	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3146	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3147	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3148	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3149	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3150	/* Mic2 (as headphone out) for HP output */
3151	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3152	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3153	/* Line In pin widget for input */
3154	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3155	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3156	/* Line2 (as front mic) pin widget for input and vref at 80% */
3157	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3158	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3159	/* CD pin widget for input */
3160	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3161
3162	{ }
3163};
3164
3165/*
3166 * 5-stack pin configuration:
3167 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
3168 * line-in/side = 0x1a, f-mic = 0x1b
3169 */
3170static struct hda_verb alc880_pin_5stack_init_verbs[] = {
3171	/*
3172	 * preset connection lists of input pins
3173	 * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
3174	 */
3175	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3176	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
3177
3178	/*
3179	 * Set pin mode and muting
3180	 */
3181	/* set pin widgets 0x14-0x17 for output */
3182	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3183	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3184	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3185	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3186	/* unmute pins for output (no gain on this amp) */
3187	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3188	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3190	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3191
3192	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3193	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3194	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3195	/* Mic2 (as headphone out) for HP output */
3196	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3197	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3198	/* Line In pin widget for input */
3199	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3200	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3201	/* Line2 (as front mic) pin widget for input and vref at 80% */
3202	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3203	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3204	/* CD pin widget for input */
3205	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3206
3207	{ }
3208};
3209
3210/*
3211 * W810 pin configuration:
3212 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
3213 */
3214static struct hda_verb alc880_pin_w810_init_verbs[] = {
3215	/* hphone/speaker input selector: front DAC */
3216	{0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
3217
3218	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3219	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3220	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3221	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3222	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3223	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3224
3225	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3226	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3227
3228	{ }
3229};
3230
3231/*
3232 * Z71V pin configuration:
3233 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
3234 */
3235static struct hda_verb alc880_pin_z71v_init_verbs[] = {
3236	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3237	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3238	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3239	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3240
3241	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3242	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3243	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3244	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3245
3246	{ }
3247};
3248
3249/*
3250 * 6-stack pin configuration:
3251 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
3252 * f-mic = 0x19, line = 0x1a, HP = 0x1b
3253 */
3254static struct hda_verb alc880_pin_6stack_init_verbs[] = {
3255	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3256
3257	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3258	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3259	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3260	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3261	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3262	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3263	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3264	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3265
3266	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3267	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3268	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3269	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3270	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3271	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3272	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3273	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3274	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3275
3276	{ }
3277};
3278
3279/*
3280 * Uniwill pin configuration:
3281 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3282 * line = 0x1a
3283 */
3284static struct hda_verb alc880_uniwill_init_verbs[] = {
3285	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3286
3287	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3288	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3289	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3290	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3291	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3292	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3293	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3294	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3295	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3296	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3297	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3298	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3299	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3300	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3301
3302	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3303	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3304	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3305	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3306	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3307	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3308	/* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3309	/* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3310	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3311
3312	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3313	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3314
3315	{ }
3316};
3317
3318/*
3319* Uniwill P53
3320* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3321 */
3322static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3323	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3324
3325	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3326	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3327	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3328	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3329	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3330	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3331	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3332	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3333	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3334	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3335	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3336	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3337
3338	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3339	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3340	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3341	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3342	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3343	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3344
3345	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3346	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3347
3348	{ }
3349};
3350
3351static struct hda_verb alc880_beep_init_verbs[] = {
3352	{ 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3353	{ }
3354};
3355
3356/* auto-toggle front mic */
3357static void alc88x_simple_mic_automute(struct hda_codec *codec)
3358{
3359 	unsigned int present;
3360	unsigned char bits;
3361
3362	present = snd_hda_jack_detect(codec, 0x18);
3363	bits = present ? HDA_AMP_MUTE : 0;
3364	snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3365}
3366
3367static void alc880_uniwill_setup(struct hda_codec *codec)
3368{
3369	struct alc_spec *spec = codec->spec;
3370
3371	spec->autocfg.hp_pins[0] = 0x14;
3372	spec->autocfg.speaker_pins[0] = 0x15;
3373	spec->autocfg.speaker_pins[0] = 0x16;
3374}
3375
3376static void alc880_uniwill_init_hook(struct hda_codec *codec)
3377{
3378	alc_automute_amp(codec);
3379	alc88x_simple_mic_automute(codec);
3380}
3381
3382static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3383				       unsigned int res)
3384{
3385	/* Looks like the unsol event is incompatible with the standard
3386	 * definition.  4bit tag is placed at 28 bit!
3387	 */
3388	switch (res >> 28) {
3389	case ALC880_MIC_EVENT:
3390		alc88x_simple_mic_automute(codec);
3391		break;
3392	default:
3393		alc_automute_amp_unsol_event(codec, res);
3394		break;
3395	}
3396}
3397
3398static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3399{
3400	struct alc_spec *spec = codec->spec;
3401
3402	spec->autocfg.hp_pins[0] = 0x14;
3403	spec->autocfg.speaker_pins[0] = 0x15;
3404}
3405
3406static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3407{
3408	unsigned int present;
3409
3410	present = snd_hda_codec_read(codec, 0x21, 0,
3411				     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3412	present &= HDA_AMP_VOLMASK;
3413	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3414				 HDA_AMP_VOLMASK, present);
3415	snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3416				 HDA_AMP_VOLMASK, present);
3417}
3418
3419static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3420					   unsigned int res)
3421{
3422	/* Looks like the unsol event is incompatible with the standard
3423	 * definition.  4bit tag is placed at 28 bit!
3424	 */
3425	if ((res >> 28) == ALC880_DCVOL_EVENT)
3426		alc880_uniwill_p53_dcvol_automute(codec);
3427	else
3428		alc_automute_amp_unsol_event(codec, res);
3429}
3430
3431/*
3432 * F1734 pin configuration:
3433 * HP = 0x14, speaker-out = 0x15, mic = 0x18
3434 */
3435static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3436	{0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3437	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3438	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3439	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3440	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3441
3442	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3443	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3444	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3445	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3446
3447	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3448	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3449	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3450	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3451	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3452	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3453	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3454	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3455	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3456
3457	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3458	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3459
3460	{ }
3461};
3462
3463/*
3464 * ASUS pin configuration:
3465 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3466 */
3467static struct hda_verb alc880_pin_asus_init_verbs[] = {
3468	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3469	{0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3470	{0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3471	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3472
3473	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3474	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3476	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3477	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3478	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3479	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3480	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3481
3482	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3483	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3484	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3485	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3486	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3487	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3488	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3489	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3490	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3491
3492	{ }
3493};
3494
3495/* Enable GPIO mask and set output */
3496#define alc880_gpio1_init_verbs	alc_gpio1_init_verbs
3497#define alc880_gpio2_init_verbs	alc_gpio2_init_verbs
3498#define alc880_gpio3_init_verbs	alc_gpio3_init_verbs
3499
3500/* Clevo m520g init */
3501static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3502	/* headphone output */
3503	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3504	/* line-out */
3505	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3506	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3507	/* Line-in */
3508	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3509	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3510	/* CD */
3511	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3512	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3513	/* Mic1 (rear panel) */
3514	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3515	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3516	/* Mic2 (front panel) */
3517	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3518	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3519	/* headphone */
3520	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3521	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3522        /* change to EAPD mode */
3523	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3524	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3525
3526	{ }
3527};
3528
3529static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3530	/* change to EAPD mode */
3531	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3532	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3533
3534	/* Headphone output */
3535	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3536	/* Front output*/
3537	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3538	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3539
3540	/* Line In pin widget for input */
3541	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3542	/* CD pin widget for input */
3543	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3544	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3545	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3546
3547	/* change to EAPD mode */
3548	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3549	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3550
3551	{ }
3552};
3553
3554/*
3555 * LG m1 express dual
3556 *
3557 * Pin assignment:
3558 *   Rear Line-In/Out (blue): 0x14
3559 *   Build-in Mic-In: 0x15
3560 *   Speaker-out: 0x17
3561 *   HP-Out (green): 0x1b
3562 *   Mic-In/Out (red): 0x19
3563 *   SPDIF-Out: 0x1e
3564 */
3565
3566/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3567static hda_nid_t alc880_lg_dac_nids[3] = {
3568	0x05, 0x02, 0x03
3569};
3570
3571/* seems analog CD is not working */
3572static struct hda_input_mux alc880_lg_capture_source = {
3573	.num_items = 3,
3574	.items = {
3575		{ "Mic", 0x1 },
3576		{ "Line", 0x5 },
3577		{ "Internal Mic", 0x6 },
3578	},
3579};
3580
3581/* 2,4,6 channel modes */
3582static struct hda_verb alc880_lg_ch2_init[] = {
3583	/* set line-in and mic-in to input */
3584	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3585	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3586	{ }
3587};
3588
3589static struct hda_verb alc880_lg_ch4_init[] = {
3590	/* set line-in to out and mic-in to input */
3591	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3592	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3593	{ }
3594};
3595
3596static struct hda_verb alc880_lg_ch6_init[] = {
3597	/* set line-in and mic-in to output */
3598	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3599	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3600	{ }
3601};
3602
3603static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3604	{ 2, alc880_lg_ch2_init },
3605	{ 4, alc880_lg_ch4_init },
3606	{ 6, alc880_lg_ch6_init },
3607};
3608
3609static struct snd_kcontrol_new alc880_lg_mixer[] = {
3610	HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3611	HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3612	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3613	HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3614	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3615	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3616	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3617	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3618	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3619	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3620	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3621	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3622	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3623	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3624	{
3625		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3626		.name = "Channel Mode",
3627		.info = alc_ch_mode_info,
3628		.get = alc_ch_mode_get,
3629		.put = alc_ch_mode_put,
3630	},
3631	{ } /* end */
3632};
3633
3634static struct hda_verb alc880_lg_init_verbs[] = {
3635	/* set capture source to mic-in */
3636	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3637	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3638	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3639	/* mute all amp mixer inputs */
3640	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3641	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3642	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3643	/* line-in to input */
3644	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3645	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3646	/* built-in mic */
3647	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3648	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3649	/* speaker-out */
3650	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3651	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3652	/* mic-in to input */
3653	{0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3654	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3655	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3656	/* HP-out */
3657	{0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3658	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3659	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3660	/* jack sense */
3661	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3662	{ }
3663};
3664
3665/* toggle speaker-output according to the hp-jack state */
3666static void alc880_lg_setup(struct hda_codec *codec)
3667{
3668	struct alc_spec *spec = codec->spec;
3669
3670	spec->autocfg.hp_pins[0] = 0x1b;
3671	spec->autocfg.speaker_pins[0] = 0x17;
3672}
3673
3674/*
3675 * LG LW20
3676 *
3677 * Pin assignment:
3678 *   Speaker-out: 0x14
3679 *   Mic-In: 0x18
3680 *   Built-in Mic-In: 0x19
3681 *   Line-In: 0x1b
3682 *   HP-Out: 0x1a
3683 *   SPDIF-Out: 0x1e
3684 */
3685
3686static struct hda_input_mux alc880_lg_lw_capture_source = {
3687	.num_items = 3,
3688	.items = {
3689		{ "Mic", 0x0 },
3690		{ "Internal Mic", 0x1 },
3691		{ "Line In", 0x2 },
3692	},
3693};
3694
3695#define alc880_lg_lw_modes alc880_threestack_modes
3696
3697static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3698	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3699	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3700	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3701	HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3702	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3703	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3704	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3705	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3706	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3707	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3708	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3709	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3710	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3711	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3712	{
3713		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3714		.name = "Channel Mode",
3715		.info = alc_ch_mode_info,
3716		.get = alc_ch_mode_get,
3717		.put = alc_ch_mode_put,
3718	},
3719	{ } /* end */
3720};
3721
3722static struct hda_verb alc880_lg_lw_init_verbs[] = {
3723	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3724	{0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3725	{0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3726
3727	/* set capture source to mic-in */
3728	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3729	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3730	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3731	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3732	/* speaker-out */
3733	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3734	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3735	/* HP-out */
3736	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3737	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3738	/* mic-in to input */
3739	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3740	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3741	/* built-in mic */
3742	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3743	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3744	/* jack sense */
3745	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3746	{ }
3747};
3748
3749/* toggle speaker-output according to the hp-jack state */
3750static void alc880_lg_lw_setup(struct hda_codec *codec)
3751{
3752	struct alc_spec *spec = codec->spec;
3753
3754	spec->autocfg.hp_pins[0] = 0x1b;
3755	spec->autocfg.speaker_pins[0] = 0x14;
3756}
3757
3758static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3759	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3760	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3761	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3762	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3763	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3764	HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3765	{ } /* end */
3766};
3767
3768static struct hda_input_mux alc880_medion_rim_capture_source = {
3769	.num_items = 2,
3770	.items = {
3771		{ "Mic", 0x0 },
3772		{ "Internal Mic", 0x1 },
3773	},
3774};
3775
3776static struct hda_verb alc880_medion_rim_init_verbs[] = {
3777	{0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3778
3779	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3780	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3781
3782	/* Mic1 (rear panel) pin widget for input and vref at 80% */
3783	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3784	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3785	/* Mic2 (as headphone out) for HP output */
3786	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3787	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3788	/* Internal Speaker */
3789	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3790	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3791
3792	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3793	{0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3794
3795	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3796	{ }
3797};
3798
3799/* toggle speaker-output according to the hp-jack state */
3800static void alc880_medion_rim_automute(struct hda_codec *codec)
3801{
3802	struct alc_spec *spec = codec->spec;
3803	alc_automute_amp(codec);
3804	/* toggle EAPD */
3805	if (spec->jack_present)
3806		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3807	else
3808		snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3809}
3810
3811static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3812					  unsigned int res)
3813{
3814	/* Looks like the unsol event is incompatible with the standard
3815	 * definition.  4bit tag is placed at 28 bit!
3816	 */
3817	if ((res >> 28) == ALC880_HP_EVENT)
3818		alc880_medion_rim_automute(codec);
3819}
3820
3821static void alc880_medion_rim_setup(struct hda_codec *codec)
3822{
3823	struct alc_spec *spec = codec->spec;
3824
3825	spec->autocfg.hp_pins[0] = 0x14;
3826	spec->autocfg.speaker_pins[0] = 0x1b;
3827}
3828
3829#ifdef CONFIG_SND_HDA_POWER_SAVE
3830static struct hda_amp_list alc880_loopbacks[] = {
3831	{ 0x0b, HDA_INPUT, 0 },
3832	{ 0x0b, HDA_INPUT, 1 },
3833	{ 0x0b, HDA_INPUT, 2 },
3834	{ 0x0b, HDA_INPUT, 3 },
3835	{ 0x0b, HDA_INPUT, 4 },
3836	{ } /* end */
3837};
3838
3839static struct hda_amp_list alc880_lg_loopbacks[] = {
3840	{ 0x0b, HDA_INPUT, 1 },
3841	{ 0x0b, HDA_INPUT, 6 },
3842	{ 0x0b, HDA_INPUT, 7 },
3843	{ } /* end */
3844};
3845#endif
3846
3847/*
3848 * Common callbacks
3849 */
3850
3851static void alc_init_special_input_src(struct hda_codec *codec);
3852
3853static int alc_init(struct hda_codec *codec)
3854{
3855	struct alc_spec *spec = codec->spec;
3856	unsigned int i;
3857
3858	alc_fix_pll(codec);
3859	alc_auto_init_amp(codec, spec->init_amp);
3860
3861	for (i = 0; i < spec->num_init_verbs; i++)
3862		snd_hda_sequence_write(codec, spec->init_verbs[i]);
3863	alc_init_special_input_src(codec);
3864
3865	if (spec->init_hook)
3866		spec->init_hook(codec);
3867
3868	alc_apply_fixup(codec, ALC_FIXUP_ACT_INIT);
3869
3870	hda_call_check_power_status(codec, 0x01);
3871	return 0;
3872}
3873
3874static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3875{
3876	struct alc_spec *spec = codec->spec;
3877
3878	if (spec->unsol_event)
3879		spec->unsol_event(codec, res);
3880}
3881
3882#ifdef CONFIG_SND_HDA_POWER_SAVE
3883static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3884{
3885	struct alc_spec *spec = codec->spec;
3886	return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3887}
3888#endif
3889
3890/*
3891 * Analog playback callbacks
3892 */
3893static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3894				    struct hda_codec *codec,
3895				    struct snd_pcm_substream *substream)
3896{
3897	struct alc_spec *spec = codec->spec;
3898	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3899					     hinfo);
3900}
3901
3902static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3903				       struct hda_codec *codec,
3904				       unsigned int stream_tag,
3905				       unsigned int format,
3906				       struct snd_pcm_substream *substream)
3907{
3908	struct alc_spec *spec = codec->spec;
3909	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3910						stream_tag, format, substream);
3911}
3912
3913static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3914				       struct hda_codec *codec,
3915				       struct snd_pcm_substream *substream)
3916{
3917	struct alc_spec *spec = codec->spec;
3918	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3919}
3920
3921/*
3922 * Digital out
3923 */
3924static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3925					struct hda_codec *codec,
3926					struct snd_pcm_substream *substream)
3927{
3928	struct alc_spec *spec = codec->spec;
3929	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3930}
3931
3932static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3933					   struct hda_codec *codec,
3934					   unsigned int stream_tag,
3935					   unsigned int format,
3936					   struct snd_pcm_substream *substream)
3937{
3938	struct alc_spec *spec = codec->spec;
3939	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3940					     stream_tag, format, substream);
3941}
3942
3943static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3944					   struct hda_codec *codec,
3945					   struct snd_pcm_substream *substream)
3946{
3947	struct alc_spec *spec = codec->spec;
3948	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3949}
3950
3951static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3952					 struct hda_codec *codec,
3953					 struct snd_pcm_substream *substream)
3954{
3955	struct alc_spec *spec = codec->spec;
3956	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3957}
3958
3959/*
3960 * Analog capture
3961 */
3962static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3963				      struct hda_codec *codec,
3964				      unsigned int stream_tag,
3965				      unsigned int format,
3966				      struct snd_pcm_substream *substream)
3967{
3968	struct alc_spec *spec = codec->spec;
3969
3970	snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3971				   stream_tag, 0, format);
3972	return 0;
3973}
3974
3975static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3976				      struct hda_codec *codec,
3977				      struct snd_pcm_substream *substream)
3978{
3979	struct alc_spec *spec = codec->spec;
3980
3981	snd_hda_codec_cleanup_stream(codec,
3982				     spec->adc_nids[substream->number + 1]);
3983	return 0;
3984}
3985
3986/* analog capture with dynamic dual-adc changes */
3987static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3988				       struct hda_codec *codec,
3989				       unsigned int stream_tag,
3990				       unsigned int format,
3991				       struct snd_pcm_substream *substream)
3992{
3993	struct alc_spec *spec = codec->spec;
3994	spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3995	spec->cur_adc_stream_tag = stream_tag;
3996	spec->cur_adc_format = format;
3997	snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3998	return 0;
3999}
4000
4001static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
4002				       struct hda_codec *codec,
4003				       struct snd_pcm_substream *substream)
4004{
4005	struct alc_spec *spec = codec->spec;
4006	snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
4007	spec->cur_adc = 0;
4008	return 0;
4009}
4010
4011static struct hda_pcm_stream dualmic_pcm_analog_capture = {
4012	.substreams = 1,
4013	.channels_min = 2,
4014	.channels_max = 2,
4015	.nid = 0, /* fill later */
4016	.ops = {
4017		.prepare = dualmic_capture_pcm_prepare,
4018		.cleanup = dualmic_capture_pcm_cleanup
4019	},
4020};
4021
4022/*
4023 */
4024static struct hda_pcm_stream alc880_pcm_analog_playback = {
4025	.substreams = 1,
4026	.channels_min = 2,
4027	.channels_max = 8,
4028	/* NID is set in alc_build_pcms */
4029	.ops = {
4030		.open = alc880_playback_pcm_open,
4031		.prepare = alc880_playback_pcm_prepare,
4032		.cleanup = alc880_playback_pcm_cleanup
4033	},
4034};
4035
4036static struct hda_pcm_stream alc880_pcm_analog_capture = {
4037	.substreams = 1,
4038	.channels_min = 2,
4039	.channels_max = 2,
4040	/* NID is set in alc_build_pcms */
4041};
4042
4043static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
4044	.substreams = 1,
4045	.channels_min = 2,
4046	.channels_max = 2,
4047	/* NID is set in alc_build_pcms */
4048};
4049
4050static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
4051	.substreams = 2, /* can be overridden */
4052	.channels_min = 2,
4053	.channels_max = 2,
4054	/* NID is set in alc_build_pcms */
4055	.ops = {
4056		.prepare = alc880_alt_capture_pcm_prepare,
4057		.cleanup = alc880_alt_capture_pcm_cleanup
4058	},
4059};
4060
4061static struct hda_pcm_stream alc880_pcm_digital_playback = {
4062	.substreams = 1,
4063	.channels_min = 2,
4064	.channels_max = 2,
4065	/* NID is set in alc_build_pcms */
4066	.ops = {
4067		.open = alc880_dig_playback_pcm_open,
4068		.close = alc880_dig_playback_pcm_close,
4069		.prepare = alc880_dig_playback_pcm_prepare,
4070		.cleanup = alc880_dig_playback_pcm_cleanup
4071	},
4072};
4073
4074static struct hda_pcm_stream alc880_pcm_digital_capture = {
4075	.substreams = 1,
4076	.channels_min = 2,
4077	.channels_max = 2,
4078	/* NID is set in alc_build_pcms */
4079};
4080
4081/* Used by alc_build_pcms to flag that a PCM has no playback stream */
4082static struct hda_pcm_stream alc_pcm_null_stream = {
4083	.substreams = 0,
4084	.channels_min = 0,
4085	.channels_max = 0,
4086};
4087
4088static int alc_build_pcms(struct hda_codec *codec)
4089{
4090	struct alc_spec *spec = codec->spec;
4091	struct hda_pcm *info = spec->pcm_rec;
4092	int i;
4093
4094	codec->num_pcms = 1;
4095	codec->pcm_info = info;
4096
4097	if (spec->no_analog)
4098		goto skip_analog;
4099
4100	snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
4101		 "%s Analog", codec->chip_name);
4102	info->name = spec->stream_name_analog;
4103
4104	if (spec->stream_analog_playback) {
4105		if (snd_BUG_ON(!spec->multiout.dac_nids))
4106			return -EINVAL;
4107		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
4108		info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
4109	}
4110	if (spec->stream_analog_capture) {
4111		if (snd_BUG_ON(!spec->adc_nids))
4112			return -EINVAL;
4113		info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
4114		info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
4115	}
4116
4117	if (spec->channel_mode) {
4118		info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
4119		for (i = 0; i < spec->num_channel_mode; i++) {
4120			if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
4121				info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
4122			}
4123		}
4124	}
4125
4126 skip_analog:
4127	/* SPDIF for stream index #1 */
4128	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
4129		snprintf(spec->stream_name_digital,
4130			 sizeof(spec->stream_name_digital),
4131			 "%s Digital", codec->chip_name);
4132		codec->num_pcms = 2;
4133	        codec->slave_dig_outs = spec->multiout.slave_dig_outs;
4134		info = spec->pcm_rec + 1;
4135		info->name = spec->stream_name_digital;
4136		if (spec->dig_out_type)
4137			info->pcm_type = spec->dig_out_type;
4138		else
4139			info->pcm_type = HDA_PCM_TYPE_SPDIF;
4140		if (spec->multiout.dig_out_nid &&
4141		    spec->stream_digital_playback) {
4142			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
4143			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
4144		}
4145		if (spec->dig_in_nid &&
4146		    spec->stream_digital_capture) {
4147			info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
4148			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
4149		}
4150		/* FIXME: do we need this for all Realtek codec models? */
4151		codec->spdif_status_reset = 1;
4152	}
4153
4154	if (spec->no_analog)
4155		return 0;
4156
4157	/* If the use of more than one ADC is requested for the current
4158	 * model, configure a second analog capture-only PCM.
4159	 */
4160	/* Additional Analaog capture for index #2 */
4161	if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
4162	    (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
4163		codec->num_pcms = 3;
4164		info = spec->pcm_rec + 2;
4165		info->name = spec->stream_name_analog;
4166		if (spec->alt_dac_nid) {
4167			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4168				*spec->stream_analog_alt_playback;
4169			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
4170				spec->alt_dac_nid;
4171		} else {
4172			info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
4173				alc_pcm_null_stream;
4174			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
4175		}
4176		if (spec->num_adc_nids > 1) {
4177			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4178				*spec->stream_analog_alt_capture;
4179			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
4180				spec->adc_nids[1];
4181			info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
4182				spec->num_adc_nids - 1;
4183		} else {
4184			info->stream[SNDRV_PCM_STREAM_CAPTURE] =
4185				alc_pcm_null_stream;
4186			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
4187		}
4188	}
4189
4190	return 0;
4191}
4192
4193static inline void alc_shutup(struct hda_codec *codec)
4194{
4195	snd_hda_shutup_pins(codec);
4196}
4197
4198static void alc_free_kctls(struct hda_codec *codec)
4199{
4200	struct alc_spec *spec = codec->spec;
4201
4202	if (spec->kctls.list) {
4203		struct snd_kcontrol_new *kctl = spec->kctls.list;
4204		int i;
4205		for (i = 0; i < spec->kctls.used; i++)
4206			kfree(kctl[i].name);
4207	}
4208	snd_array_free(&spec->kctls);
4209}
4210
4211static void alc_free(struct hda_codec *codec)
4212{
4213	struct alc_spec *spec = codec->spec;
4214
4215	if (!spec)
4216		return;
4217
4218	alc_shutup(codec);
4219	snd_hda_input_jack_free(codec);
4220	alc_free_kctls(codec);
4221	kfree(spec);
4222	snd_hda_detach_beep_device(codec);
4223}
4224
4225#ifdef CONFIG_SND_HDA_POWER_SAVE
4226static void alc_power_eapd(struct hda_codec *codec)
4227{
4228	/* We currently only handle front, HP */
4229	switch (codec->vendor_id) {
4230	case 0x10ec0260:
4231		set_eapd(codec, 0x0f, 0);
4232		set_eapd(codec, 0x10, 0);
4233		break;
4234	case 0x10ec0262:
4235	case 0x10ec0267:
4236	case 0x10ec0268:
4237	case 0x10ec0269:
4238	case 0x10ec0270:
4239	case 0x10ec0272:
4240	case 0x10ec0660:
4241	case 0x10ec0662:
4242	case 0x10ec0663:
4243	case 0x10ec0862:
4244	case 0x10ec0889:
4245		set_eapd(codec, 0x14, 0);
4246		set_eapd(codec, 0x15, 0);
4247		break;
4248	}
4249}
4250
4251static int alc_suspend(struct hda_codec *codec, pm_message_t state)
4252{
4253	struct alc_spec *spec = codec->spec;
4254	alc_shutup(codec);
4255	if (spec && spec->power_hook)
4256		spec->power_hook(codec);
4257	return 0;
4258}
4259#endif
4260
4261#ifdef SND_HDA_NEEDS_RESUME
4262static int alc_resume(struct hda_codec *codec)
4263{
4264	codec->patch_ops.init(codec);
4265	snd_hda_codec_resume_amp(codec);
4266	snd_hda_codec_resume_cache(codec);
4267	hda_call_check_power_status(codec, 0x01);
4268	return 0;
4269}
4270#endif
4271
4272/*
4273 */
4274static struct hda_codec_ops alc_patch_ops = {
4275	.build_controls = alc_build_controls,
4276	.build_pcms = alc_build_pcms,
4277	.init = alc_init,
4278	.free = alc_free,
4279	.unsol_event = alc_unsol_event,
4280#ifdef SND_HDA_NEEDS_RESUME
4281	.resume = alc_resume,
4282#endif
4283#ifdef CONFIG_SND_HDA_POWER_SAVE
4284	.suspend = alc_suspend,
4285	.check_power_status = alc_check_power_status,
4286#endif
4287	.reboot_notify = alc_shutup,
4288};
4289
4290/* replace the codec chip_name with the given string */
4291static int alc_codec_rename(struct hda_codec *codec, const char *name)
4292{
4293	kfree(codec->chip_name);
4294	codec->chip_name = kstrdup(name, GFP_KERNEL);
4295	if (!codec->chip_name) {
4296		alc_free(codec);
4297		return -ENOMEM;
4298	}
4299	return 0;
4300}
4301
4302/*
4303 * Test configuration for debugging
4304 *
4305 * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4306 * enum controls.
4307 */
4308#ifdef CONFIG_SND_DEBUG
4309static hda_nid_t alc880_test_dac_nids[4] = {
4310	0x02, 0x03, 0x04, 0x05
4311};
4312
4313static struct hda_input_mux alc880_test_capture_source = {
4314	.num_items = 7,
4315	.items = {
4316		{ "In-1", 0x0 },
4317		{ "In-2", 0x1 },
4318		{ "In-3", 0x2 },
4319		{ "In-4", 0x3 },
4320		{ "CD", 0x4 },
4321		{ "Front", 0x5 },
4322		{ "Surround", 0x6 },
4323	},
4324};
4325
4326static struct hda_channel_mode alc880_test_modes[4] = {
4327	{ 2, NULL },
4328	{ 4, NULL },
4329	{ 6, NULL },
4330	{ 8, NULL },
4331};
4332
4333static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4334				 struct snd_ctl_elem_info *uinfo)
4335{
4336	static char *texts[] = {
4337		"N/A", "Line Out", "HP Out",
4338		"In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4339	};
4340	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4341	uinfo->count = 1;
4342	uinfo->value.enumerated.items = 8;
4343	if (uinfo->value.enumerated.item >= 8)
4344		uinfo->value.enumerated.item = 7;
4345	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4346	return 0;
4347}
4348
4349static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4350				struct snd_ctl_elem_value *ucontrol)
4351{
4352	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4353	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4354	unsigned int pin_ctl, item = 0;
4355
4356	pin_ctl = snd_hda_codec_read(codec, nid, 0,
4357				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4358	if (pin_ctl & AC_PINCTL_OUT_EN) {
4359		if (pin_ctl & AC_PINCTL_HP_EN)
4360			item = 2;
4361		else
4362			item = 1;
4363	} else if (pin_ctl & AC_PINCTL_IN_EN) {
4364		switch (pin_ctl & AC_PINCTL_VREFEN) {
4365		case AC_PINCTL_VREF_HIZ: item = 3; break;
4366		case AC_PINCTL_VREF_50:  item = 4; break;
4367		case AC_PINCTL_VREF_GRD: item = 5; break;
4368		case AC_PINCTL_VREF_80:  item = 6; break;
4369		case AC_PINCTL_VREF_100: item = 7; break;
4370		}
4371	}
4372	ucontrol->value.enumerated.item[0] = item;
4373	return 0;
4374}
4375
4376static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4377				struct snd_ctl_elem_value *ucontrol)
4378{
4379	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4380	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4381	static unsigned int ctls[] = {
4382		0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4383		AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4384		AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4385		AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4386		AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4387		AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4388	};
4389	unsigned int old_ctl, new_ctl;
4390
4391	old_ctl = snd_hda_codec_read(codec, nid, 0,
4392				     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4393	new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4394	if (old_ctl != new_ctl) {
4395		int val;
4396		snd_hda_codec_write_cache(codec, nid, 0,
4397					  AC_VERB_SET_PIN_WIDGET_CONTROL,
4398					  new_ctl);
4399		val = ucontrol->value.enumerated.item[0] >= 3 ?
4400			HDA_AMP_MUTE : 0;
4401		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4402					 HDA_AMP_MUTE, val);
4403		return 1;
4404	}
4405	return 0;
4406}
4407
4408static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4409				 struct snd_ctl_elem_info *uinfo)
4410{
4411	static char *texts[] = {
4412		"Front", "Surround", "CLFE", "Side"
4413	};
4414	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4415	uinfo->count = 1;
4416	uinfo->value.enumerated.items = 4;
4417	if (uinfo->value.enumerated.item >= 4)
4418		uinfo->value.enumerated.item = 3;
4419	strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4420	return 0;
4421}
4422
4423static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4424				struct snd_ctl_elem_value *ucontrol)
4425{
4426	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4427	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4428	unsigned int sel;
4429
4430	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4431	ucontrol->value.enumerated.item[0] = sel & 3;
4432	return 0;
4433}
4434
4435static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4436				struct snd_ctl_elem_value *ucontrol)
4437{
4438	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4439	hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4440	unsigned int sel;
4441
4442	sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4443	if (ucontrol->value.enumerated.item[0] != sel) {
4444		sel = ucontrol->value.enumerated.item[0] & 3;
4445		snd_hda_codec_write_cache(codec, nid, 0,
4446					  AC_VERB_SET_CONNECT_SEL, sel);
4447		return 1;
4448	}
4449	return 0;
4450}
4451
4452#define PIN_CTL_TEST(xname,nid) {			\
4453		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
4454			.name = xname,		       \
4455			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4456			.info = alc_test_pin_ctl_info, \
4457			.get = alc_test_pin_ctl_get,   \
4458			.put = alc_test_pin_ctl_put,   \
4459			.private_value = nid	       \
4460			}
4461
4462#define PIN_SRC_TEST(xname,nid) {			\
4463		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,	\
4464			.name = xname,		       \
4465			.subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4466			.info = alc_test_pin_src_info, \
4467			.get = alc_test_pin_src_get,   \
4468			.put = alc_test_pin_src_put,   \
4469			.private_value = nid	       \
4470			}
4471
4472static struct snd_kcontrol_new alc880_test_mixer[] = {
4473	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4474	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4475	HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4476	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4477	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4478	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4479	HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4480	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4481	PIN_CTL_TEST("Front Pin Mode", 0x14),
4482	PIN_CTL_TEST("Surround Pin Mode", 0x15),
4483	PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4484	PIN_CTL_TEST("Side Pin Mode", 0x17),
4485	PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4486	PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4487	PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4488	PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4489	PIN_SRC_TEST("In-1 Pin Source", 0x18),
4490	PIN_SRC_TEST("In-2 Pin Source", 0x19),
4491	PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4492	PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4493	HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4494	HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4495	HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4496	HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4497	HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4498	HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4499	HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4500	HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4501	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4502	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4503	{
4504		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4505		.name = "Channel Mode",
4506		.info = alc_ch_mode_info,
4507		.get = alc_ch_mode_get,
4508		.put = alc_ch_mode_put,
4509	},
4510	{ } /* end */
4511};
4512
4513static struct hda_verb alc880_test_init_verbs[] = {
4514	/* Unmute inputs of 0x0c - 0x0f */
4515	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4516	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4517	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4518	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4519	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4520	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4521	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4522	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4523	/* Vol output for 0x0c-0x0f */
4524	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4525	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4526	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4527	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4528	/* Set output pins 0x14-0x17 */
4529	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4530	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4531	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4532	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4533	/* Unmute output pins 0x14-0x17 */
4534	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4535	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4536	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4537	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4538	/* Set input pins 0x18-0x1c */
4539	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4540	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4541	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4542	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4543	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4544	/* Mute input pins 0x18-0x1b */
4545	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4546	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4547	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4548	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4549	/* ADC set up */
4550	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4551	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4552	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4553	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4554	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4555	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4556	/* Analog input/passthru */
4557	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4558	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4559	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4560	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4561	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4562	{ }
4563};
4564#endif
4565
4566/*
4567 */
4568
4569static const char * const alc880_models[ALC880_MODEL_LAST] = {
4570	[ALC880_3ST]		= "3stack",
4571	[ALC880_TCL_S700]	= "tcl",
4572	[ALC880_3ST_DIG]	= "3stack-digout",
4573	[ALC880_CLEVO]		= "clevo",
4574	[ALC880_5ST]		= "5stack",
4575	[ALC880_5ST_DIG]	= "5stack-digout",
4576	[ALC880_W810]		= "w810",
4577	[ALC880_Z71V]		= "z71v",
4578	[ALC880_6ST]		= "6stack",
4579	[ALC880_6ST_DIG]	= "6stack-digout",
4580	[ALC880_ASUS]		= "asus",
4581	[ALC880_ASUS_W1V]	= "asus-w1v",
4582	[ALC880_ASUS_DIG]	= "asus-dig",
4583	[ALC880_ASUS_DIG2]	= "asus-dig2",
4584	[ALC880_UNIWILL_DIG]	= "uniwill",
4585	[ALC880_UNIWILL_P53]	= "uniwill-p53",
4586	[ALC880_FUJITSU]	= "fujitsu",
4587	[ALC880_F1734]		= "F1734",
4588	[ALC880_LG]		= "lg",
4589	[ALC880_LG_LW]		= "lg-lw",
4590	[ALC880_MEDION_RIM]	= "medion",
4591#ifdef CONFIG_SND_DEBUG
4592	[ALC880_TEST]		= "test",
4593#endif
4594	[ALC880_AUTO]		= "auto",
4595};
4596
4597static struct snd_pci_quirk alc880_cfg_tbl[] = {
4598	SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4599	SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4600	SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4601	SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4602	SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4603	SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4604	SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4605	SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4606	SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4607	SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4608	SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4609	SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4610	SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4611	SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4612	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4613	SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4614	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4615	SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4616	/* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4617	SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4618	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4619	SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4620	SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4621	SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4622	SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4623	SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4624	SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4625	SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4626	SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4627	SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4628	SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4629	SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4630	SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4631	SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4632	SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4633	SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4634	SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4635	SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4636	SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4637	SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4638	SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4639	SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4640	SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4641	SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4642	SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4643	SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4644	SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4645	SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4646	SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4647	SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4648	SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4649	SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4650	SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4651	SND_PCI_QUIRK(0x1854, 0x005f, "LG P1 Express", ALC880_LG),
4652	SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4653	SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4654	SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4655	SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4656	SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4657	SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4658	SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4659	SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4660	SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4661	SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4662	SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4663	SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4664	SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4665	SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4666	SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4667	/* default Intel */
4668	SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4669	SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4670	SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4671	{}
4672};
4673
4674/*
4675 * ALC880 codec presets
4676 */
4677static struct alc_config_preset alc880_presets[] = {
4678	[ALC880_3ST] = {
4679		.mixers = { alc880_three_stack_mixer },
4680		.init_verbs = { alc880_volume_init_verbs,
4681				alc880_pin_3stack_init_verbs },
4682		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4683		.dac_nids = alc880_dac_nids,
4684		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4685		.channel_mode = alc880_threestack_modes,
4686		.need_dac_fix = 1,
4687		.input_mux = &alc880_capture_source,
4688	},
4689	[ALC880_3ST_DIG] = {
4690		.mixers = { alc880_three_stack_mixer },
4691		.init_verbs = { alc880_volume_init_verbs,
4692				alc880_pin_3stack_init_verbs },
4693		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4694		.dac_nids = alc880_dac_nids,
4695		.dig_out_nid = ALC880_DIGOUT_NID,
4696		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4697		.channel_mode = alc880_threestack_modes,
4698		.need_dac_fix = 1,
4699		.input_mux = &alc880_capture_source,
4700	},
4701	[ALC880_TCL_S700] = {
4702		.mixers = { alc880_tcl_s700_mixer },
4703		.init_verbs = { alc880_volume_init_verbs,
4704				alc880_pin_tcl_S700_init_verbs,
4705				alc880_gpio2_init_verbs },
4706		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4707		.dac_nids = alc880_dac_nids,
4708		.adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4709		.num_adc_nids = 1, /* single ADC */
4710		.hp_nid = 0x03,
4711		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4712		.channel_mode = alc880_2_jack_modes,
4713		.input_mux = &alc880_capture_source,
4714	},
4715	[ALC880_5ST] = {
4716		.mixers = { alc880_three_stack_mixer,
4717			    alc880_five_stack_mixer},
4718		.init_verbs = { alc880_volume_init_verbs,
4719				alc880_pin_5stack_init_verbs },
4720		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4721		.dac_nids = alc880_dac_nids,
4722		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4723		.channel_mode = alc880_fivestack_modes,
4724		.input_mux = &alc880_capture_source,
4725	},
4726	[ALC880_5ST_DIG] = {
4727		.mixers = { alc880_three_stack_mixer,
4728			    alc880_five_stack_mixer },
4729		.init_verbs = { alc880_volume_init_verbs,
4730				alc880_pin_5stack_init_verbs },
4731		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4732		.dac_nids = alc880_dac_nids,
4733		.dig_out_nid = ALC880_DIGOUT_NID,
4734		.num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4735		.channel_mode = alc880_fivestack_modes,
4736		.input_mux = &alc880_capture_source,
4737	},
4738	[ALC880_6ST] = {
4739		.mixers = { alc880_six_stack_mixer },
4740		.init_verbs = { alc880_volume_init_verbs,
4741				alc880_pin_6stack_init_verbs },
4742		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4743		.dac_nids = alc880_6st_dac_nids,
4744		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4745		.channel_mode = alc880_sixstack_modes,
4746		.input_mux = &alc880_6stack_capture_source,
4747	},
4748	[ALC880_6ST_DIG] = {
4749		.mixers = { alc880_six_stack_mixer },
4750		.init_verbs = { alc880_volume_init_verbs,
4751				alc880_pin_6stack_init_verbs },
4752		.num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4753		.dac_nids = alc880_6st_dac_nids,
4754		.dig_out_nid = ALC880_DIGOUT_NID,
4755		.num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4756		.channel_mode = alc880_sixstack_modes,
4757		.input_mux = &alc880_6stack_capture_source,
4758	},
4759	[ALC880_W810] = {
4760		.mixers = { alc880_w810_base_mixer },
4761		.init_verbs = { alc880_volume_init_verbs,
4762				alc880_pin_w810_init_verbs,
4763				alc880_gpio2_init_verbs },
4764		.num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4765		.dac_nids = alc880_w810_dac_nids,
4766		.dig_out_nid = ALC880_DIGOUT_NID,
4767		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4768		.channel_mode = alc880_w810_modes,
4769		.input_mux = &alc880_capture_source,
4770	},
4771	[ALC880_Z71V] = {
4772		.mixers = { alc880_z71v_mixer },
4773		.init_verbs = { alc880_volume_init_verbs,
4774				alc880_pin_z71v_init_verbs },
4775		.num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4776		.dac_nids = alc880_z71v_dac_nids,
4777		.dig_out_nid = ALC880_DIGOUT_NID,
4778		.hp_nid = 0x03,
4779		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4780		.channel_mode = alc880_2_jack_modes,
4781		.input_mux = &alc880_capture_source,
4782	},
4783	[ALC880_F1734] = {
4784		.mixers = { alc880_f1734_mixer },
4785		.init_verbs = { alc880_volume_init_verbs,
4786				alc880_pin_f1734_init_verbs },
4787		.num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4788		.dac_nids = alc880_f1734_dac_nids,
4789		.hp_nid = 0x02,
4790		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4791		.channel_mode = alc880_2_jack_modes,
4792		.input_mux = &alc880_f1734_capture_source,
4793		.unsol_event = alc880_uniwill_p53_unsol_event,
4794		.setup = alc880_uniwill_p53_setup,
4795		.init_hook = alc_automute_amp,
4796	},
4797	[ALC880_ASUS] = {
4798		.mixers = { alc880_asus_mixer },
4799		.init_verbs = { alc880_volume_init_verbs,
4800				alc880_pin_asus_init_verbs,
4801				alc880_gpio1_init_verbs },
4802		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4803		.dac_nids = alc880_asus_dac_nids,
4804		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4805		.channel_mode = alc880_asus_modes,
4806		.need_dac_fix = 1,
4807		.input_mux = &alc880_capture_source,
4808	},
4809	[ALC880_ASUS_DIG] = {
4810		.mixers = { alc880_asus_mixer },
4811		.init_verbs = { alc880_volume_init_verbs,
4812				alc880_pin_asus_init_verbs,
4813				alc880_gpio1_init_verbs },
4814		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4815		.dac_nids = alc880_asus_dac_nids,
4816		.dig_out_nid = ALC880_DIGOUT_NID,
4817		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4818		.channel_mode = alc880_asus_modes,
4819		.need_dac_fix = 1,
4820		.input_mux = &alc880_capture_source,
4821	},
4822	[ALC880_ASUS_DIG2] = {
4823		.mixers = { alc880_asus_mixer },
4824		.init_verbs = { alc880_volume_init_verbs,
4825				alc880_pin_asus_init_verbs,
4826				alc880_gpio2_init_verbs }, /* use GPIO2 */
4827		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4828		.dac_nids = alc880_asus_dac_nids,
4829		.dig_out_nid = ALC880_DIGOUT_NID,
4830		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4831		.channel_mode = alc880_asus_modes,
4832		.need_dac_fix = 1,
4833		.input_mux = &alc880_capture_source,
4834	},
4835	[ALC880_ASUS_W1V] = {
4836		.mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4837		.init_verbs = { alc880_volume_init_verbs,
4838				alc880_pin_asus_init_verbs,
4839				alc880_gpio1_init_verbs },
4840		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4841		.dac_nids = alc880_asus_dac_nids,
4842		.dig_out_nid = ALC880_DIGOUT_NID,
4843		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4844		.channel_mode = alc880_asus_modes,
4845		.need_dac_fix = 1,
4846		.input_mux = &alc880_capture_source,
4847	},
4848	[ALC880_UNIWILL_DIG] = {
4849		.mixers = { alc880_asus_mixer },
4850		.init_verbs = { alc880_volume_init_verbs,
4851				alc880_pin_asus_init_verbs },
4852		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4853		.dac_nids = alc880_asus_dac_nids,
4854		.dig_out_nid = ALC880_DIGOUT_NID,
4855		.num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4856		.channel_mode = alc880_asus_modes,
4857		.need_dac_fix = 1,
4858		.input_mux = &alc880_capture_source,
4859	},
4860	[ALC880_UNIWILL] = {
4861		.mixers = { alc880_uniwill_mixer },
4862		.init_verbs = { alc880_volume_init_verbs,
4863				alc880_uniwill_init_verbs },
4864		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4865		.dac_nids = alc880_asus_dac_nids,
4866		.dig_out_nid = ALC880_DIGOUT_NID,
4867		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4868		.channel_mode = alc880_threestack_modes,
4869		.need_dac_fix = 1,
4870		.input_mux = &alc880_capture_source,
4871		.unsol_event = alc880_uniwill_unsol_event,
4872		.setup = alc880_uniwill_setup,
4873		.init_hook = alc880_uniwill_init_hook,
4874	},
4875	[ALC880_UNIWILL_P53] = {
4876		.mixers = { alc880_uniwill_p53_mixer },
4877		.init_verbs = { alc880_volume_init_verbs,
4878				alc880_uniwill_p53_init_verbs },
4879		.num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4880		.dac_nids = alc880_asus_dac_nids,
4881		.num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4882		.channel_mode = alc880_threestack_modes,
4883		.input_mux = &alc880_capture_source,
4884		.unsol_event = alc880_uniwill_p53_unsol_event,
4885		.setup = alc880_uniwill_p53_setup,
4886		.init_hook = alc_automute_amp,
4887	},
4888	[ALC880_FUJITSU] = {
4889		.mixers = { alc880_fujitsu_mixer },
4890		.init_verbs = { alc880_volume_init_verbs,
4891				alc880_uniwill_p53_init_verbs,
4892	       			alc880_beep_init_verbs },
4893		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4894		.dac_nids = alc880_dac_nids,
4895		.dig_out_nid = ALC880_DIGOUT_NID,
4896		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4897		.channel_mode = alc880_2_jack_modes,
4898		.input_mux = &alc880_capture_source,
4899		.unsol_event = alc880_uniwill_p53_unsol_event,
4900		.setup = alc880_uniwill_p53_setup,
4901		.init_hook = alc_automute_amp,
4902	},
4903	[ALC880_CLEVO] = {
4904		.mixers = { alc880_three_stack_mixer },
4905		.init_verbs = { alc880_volume_init_verbs,
4906				alc880_pin_clevo_init_verbs },
4907		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4908		.dac_nids = alc880_dac_nids,
4909		.hp_nid = 0x03,
4910		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4911		.channel_mode = alc880_threestack_modes,
4912		.need_dac_fix = 1,
4913		.input_mux = &alc880_capture_source,
4914	},
4915	[ALC880_LG] = {
4916		.mixers = { alc880_lg_mixer },
4917		.init_verbs = { alc880_volume_init_verbs,
4918				alc880_lg_init_verbs },
4919		.num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4920		.dac_nids = alc880_lg_dac_nids,
4921		.dig_out_nid = ALC880_DIGOUT_NID,
4922		.num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4923		.channel_mode = alc880_lg_ch_modes,
4924		.need_dac_fix = 1,
4925		.input_mux = &alc880_lg_capture_source,
4926		.unsol_event = alc_automute_amp_unsol_event,
4927		.setup = alc880_lg_setup,
4928		.init_hook = alc_automute_amp,
4929#ifdef CONFIG_SND_HDA_POWER_SAVE
4930		.loopbacks = alc880_lg_loopbacks,
4931#endif
4932	},
4933	[ALC880_LG_LW] = {
4934		.mixers = { alc880_lg_lw_mixer },
4935		.init_verbs = { alc880_volume_init_verbs,
4936				alc880_lg_lw_init_verbs },
4937		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4938		.dac_nids = alc880_dac_nids,
4939		.dig_out_nid = ALC880_DIGOUT_NID,
4940		.num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4941		.channel_mode = alc880_lg_lw_modes,
4942		.input_mux = &alc880_lg_lw_capture_source,
4943		.unsol_event = alc_automute_amp_unsol_event,
4944		.setup = alc880_lg_lw_setup,
4945		.init_hook = alc_automute_amp,
4946	},
4947	[ALC880_MEDION_RIM] = {
4948		.mixers = { alc880_medion_rim_mixer },
4949		.init_verbs = { alc880_volume_init_verbs,
4950				alc880_medion_rim_init_verbs,
4951				alc_gpio2_init_verbs },
4952		.num_dacs = ARRAY_SIZE(alc880_dac_nids),
4953		.dac_nids = alc880_dac_nids,
4954		.dig_out_nid = ALC880_DIGOUT_NID,
4955		.num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4956		.channel_mode = alc880_2_jack_modes,
4957		.input_mux = &alc880_medion_rim_capture_source,
4958		.unsol_event = alc880_medion_rim_unsol_event,
4959		.setup = alc880_medion_rim_setup,
4960		.init_hook = alc880_medion_rim_automute,
4961	},
4962#ifdef CONFIG_SND_DEBUG
4963	[ALC880_TEST] = {
4964		.mixers = { alc880_test_mixer },
4965		.init_verbs = { alc880_test_init_verbs },
4966		.num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4967		.dac_nids = alc880_test_dac_nids,
4968		.dig_out_nid = ALC880_DIGOUT_NID,
4969		.num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4970		.channel_mode = alc880_test_modes,
4971		.input_mux = &alc880_test_capture_source,
4972	},
4973#endif
4974};
4975
4976/*
4977 * Automatic parse of I/O pins from the BIOS configuration
4978 */
4979
4980enum {
4981	ALC_CTL_WIDGET_VOL,
4982	ALC_CTL_WIDGET_MUTE,
4983	ALC_CTL_BIND_MUTE,
4984};
4985static struct snd_kcontrol_new alc880_control_templates[] = {
4986	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4987	HDA_CODEC_MUTE(NULL, 0, 0, 0),
4988	HDA_BIND_MUTE(NULL, 0, 0, 0),
4989};
4990
4991/* add dynamic controls */
4992static int add_control(struct alc_spec *spec, int type, const char *name,
4993		       int cidx, unsigned long val)
4994{
4995	struct snd_kcontrol_new *knew;
4996
4997	snd_array_init(&spec->kctls, sizeof(*knew), 32);
4998	knew = snd_array_new(&spec->kctls);
4999	if (!knew)
5000		return -ENOMEM;
5001	*knew = alc880_control_templates[type];
5002	knew->name = kstrdup(name, GFP_KERNEL);
5003	if (!knew->name)
5004		return -ENOMEM;
5005	knew->index = cidx;
5006	if (get_amp_nid_(val))
5007		knew->subdevice = HDA_SUBDEV_AMP_FLAG;
5008	knew->private_value = val;
5009	return 0;
5010}
5011
5012static int add_control_with_pfx(struct alc_spec *spec, int type,
5013				const char *pfx, const char *dir,
5014				const char *sfx, int cidx, unsigned long val)
5015{
5016	char name[32];
5017	snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
5018	return add_control(spec, type, name, cidx, val);
5019}
5020
5021#define add_pb_vol_ctrl(spec, type, pfx, val)			\
5022	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
5023#define add_pb_sw_ctrl(spec, type, pfx, val)			\
5024	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
5025#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)			\
5026	add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
5027#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)			\
5028	add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
5029
5030#define alc880_is_fixed_pin(nid)	((nid) >= 0x14 && (nid) <= 0x17)
5031#define alc880_fixed_pin_idx(nid)	((nid) - 0x14)
5032#define alc880_is_multi_pin(nid)	((nid) >= 0x18)
5033#define alc880_multi_pin_idx(nid)	((nid) - 0x18)
5034#define alc880_idx_to_dac(nid)		((nid) + 0x02)
5035#define alc880_dac_to_idx(nid)		((nid) - 0x02)
5036#define alc880_idx_to_mixer(nid)	((nid) + 0x0c)
5037#define alc880_idx_to_selector(nid)	((nid) + 0x10)
5038#define ALC880_PIN_CD_NID		0x1c
5039
5040/* fill in the dac_nids table from the parsed pin configuration */
5041static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
5042				     const struct auto_pin_cfg *cfg)
5043{
5044	hda_nid_t nid;
5045	int assigned[4];
5046	int i, j;
5047
5048	memset(assigned, 0, sizeof(assigned));
5049	spec->multiout.dac_nids = spec->private_dac_nids;
5050
5051	/* check the pins hardwired to audio widget */
5052	for (i = 0; i < cfg->line_outs; i++) {
5053		nid = cfg->line_out_pins[i];
5054		if (alc880_is_fixed_pin(nid)) {
5055			int idx = alc880_fixed_pin_idx(nid);
5056			spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
5057			assigned[idx] = 1;
5058		}
5059	}
5060	/* left pins can be connect to any audio widget */
5061	for (i = 0; i < cfg->line_outs; i++) {
5062		nid = cfg->line_out_pins[i];
5063		if (alc880_is_fixed_pin(nid))
5064			continue;
5065		/* search for an empty channel */
5066		for (j = 0; j < cfg->line_outs; j++) {
5067			if (!assigned[j]) {
5068				spec->multiout.dac_nids[i] =
5069					alc880_idx_to_dac(j);
5070				assigned[j] = 1;
5071				break;
5072			}
5073		}
5074	}
5075	spec->multiout.num_dacs = cfg->line_outs;
5076	return 0;
5077}
5078
5079static const char *alc_get_line_out_pfx(const struct auto_pin_cfg *cfg,
5080					bool can_be_master)
5081{
5082	if (!cfg->hp_outs && !cfg->speaker_outs && can_be_master)
5083		return "Master";
5084
5085	switch (cfg->line_out_type) {
5086	case AUTO_PIN_SPEAKER_OUT:
5087		if (cfg->line_outs == 1)
5088			return "Speaker";
5089		break;
5090	case AUTO_PIN_HP_OUT:
5091		return "Headphone";
5092	default:
5093		if (cfg->line_outs == 1)
5094			return "PCM";
5095		break;
5096	}
5097	return NULL;
5098}
5099
5100/* add playback controls from the parsed DAC table */
5101static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
5102					     const struct auto_pin_cfg *cfg)
5103{
5104	static const char * const chname[4] = {
5105		"Front", "Surround", NULL /*CLFE*/, "Side"
5106	};
5107	const char *pfx = alc_get_line_out_pfx(cfg, false);
5108	hda_nid_t nid;
5109	int i, err;
5110
5111	for (i = 0; i < cfg->line_outs; i++) {
5112		if (!spec->multiout.dac_nids[i])
5113			continue;
5114		nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
5115		if (!pfx && i == 2) {
5116			/* Center/LFE */
5117			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5118					      "Center",
5119					  HDA_COMPOSE_AMP_VAL(nid, 1, 0,
5120							      HDA_OUTPUT));
5121			if (err < 0)
5122				return err;
5123			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5124					      "LFE",
5125					  HDA_COMPOSE_AMP_VAL(nid, 2, 0,
5126							      HDA_OUTPUT));
5127			if (err < 0)
5128				return err;
5129			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5130					     "Center",
5131					  HDA_COMPOSE_AMP_VAL(nid, 1, 2,
5132							      HDA_INPUT));
5133			if (err < 0)
5134				return err;
5135			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5136					     "LFE",
5137					  HDA_COMPOSE_AMP_VAL(nid, 2, 2,
5138							      HDA_INPUT));
5139			if (err < 0)
5140				return err;
5141		} else {
5142			const char *name = pfx;
5143			int index = i;
5144			if (!name) {
5145				name = chname[i];
5146				index = 0;
5147			}
5148			err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
5149						name, index,
5150					  HDA_COMPOSE_AMP_VAL(nid, 3, 0,
5151							      HDA_OUTPUT));
5152			if (err < 0)
5153				return err;
5154			err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
5155					       name, index,
5156					  HDA_COMPOSE_AMP_VAL(nid, 3, 2,
5157							      HDA_INPUT));
5158			if (err < 0)
5159				return err;
5160		}
5161	}
5162	return 0;
5163}
5164
5165/* add playback controls for speaker and HP outputs */
5166static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
5167					const char *pfx)
5168{
5169	hda_nid_t nid;
5170	int err;
5171
5172	if (!pin)
5173		return 0;
5174
5175	if (alc880_is_fixed_pin(pin)) {
5176		nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
5177		/* specify the DAC as the extra output */
5178		if (!spec->multiout.hp_nid)
5179			spec->multiout.hp_nid = nid;
5180		else
5181			spec->multiout.extra_out_nid[0] = nid;
5182		/* control HP volume/switch on the output mixer amp */
5183		nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
5184		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
5185				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
5186		if (err < 0)
5187			return err;
5188		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
5189				  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
5190		if (err < 0)
5191			return err;
5192	} else if (alc880_is_multi_pin(pin)) {
5193		/* set manual connection */
5194		/* we have only a switch on HP-out PIN */
5195		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
5196				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5197		if (err < 0)
5198			return err;
5199	}
5200	return 0;
5201}
5202
5203/* create input playback/capture controls for the given pin */
5204static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
5205			    const char *ctlname, int ctlidx,
5206			    int idx, hda_nid_t mix_nid)
5207{
5208	int err;
5209
5210	err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
5211			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5212	if (err < 0)
5213		return err;
5214	err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
5215			  HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
5216	if (err < 0)
5217		return err;
5218	return 0;
5219}
5220
5221static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
5222{
5223	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
5224	return (pincap & AC_PINCAP_IN) != 0;
5225}
5226
5227/* create playback/capture controls for input pins */
5228static int alc_auto_create_input_ctls(struct hda_codec *codec,
5229				      const struct auto_pin_cfg *cfg,
5230				      hda_nid_t mixer,
5231				      hda_nid_t cap1, hda_nid_t cap2)
5232{
5233	struct alc_spec *spec = codec->spec;
5234	struct hda_input_mux *imux = &spec->private_imux[0];
5235	int i, err, idx, type_idx = 0;
5236	const char *prev_label = NULL;
5237
5238	for (i = 0; i < cfg->num_inputs; i++) {
5239		hda_nid_t pin;
5240		const char *label;
5241
5242		pin = cfg->inputs[i].pin;
5243		if (!alc_is_input_pin(codec, pin))
5244			continue;
5245
5246		label = hda_get_autocfg_input_label(codec, cfg, i);
5247		if (prev_label && !strcmp(label, prev_label))
5248			type_idx++;
5249		else
5250			type_idx = 0;
5251		prev_label = label;
5252
5253		if (mixer) {
5254			idx = get_connection_index(codec, mixer, pin);
5255			if (idx >= 0) {
5256				err = new_analog_input(spec, pin,
5257						       label, type_idx,
5258						       idx, mixer);
5259				if (err < 0)
5260					return err;
5261			}
5262		}
5263
5264		if (!cap1)
5265			continue;
5266		idx = get_connection_index(codec, cap1, pin);
5267		if (idx < 0 && cap2)
5268			idx = get_connection_index(codec, cap2, pin);
5269		if (idx >= 0)
5270			snd_hda_add_imux_item(imux, label, idx, NULL);
5271	}
5272	return 0;
5273}
5274
5275static int alc880_auto_create_input_ctls(struct hda_codec *codec,
5276						const struct auto_pin_cfg *cfg)
5277{
5278	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
5279}
5280
5281static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
5282			       unsigned int pin_type)
5283{
5284	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5285			    pin_type);
5286	/* unmute pin */
5287	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
5288			    AMP_OUT_UNMUTE);
5289}
5290
5291static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5292					      hda_nid_t nid, int pin_type,
5293					      int dac_idx)
5294{
5295	alc_set_pin_output(codec, nid, pin_type);
5296	/* need the manual connection? */
5297	if (alc880_is_multi_pin(nid)) {
5298		struct alc_spec *spec = codec->spec;
5299		int idx = alc880_multi_pin_idx(nid);
5300		snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5301				    AC_VERB_SET_CONNECT_SEL,
5302				    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5303	}
5304}
5305
5306static int get_pin_type(int line_out_type)
5307{
5308	if (line_out_type == AUTO_PIN_HP_OUT)
5309		return PIN_HP;
5310	else
5311		return PIN_OUT;
5312}
5313
5314static void alc880_auto_init_multi_out(struct hda_codec *codec)
5315{
5316	struct alc_spec *spec = codec->spec;
5317	int i;
5318
5319	for (i = 0; i < spec->autocfg.line_outs; i++) {
5320		hda_nid_t nid = spec->autocfg.line_out_pins[i];
5321		int pin_type = get_pin_type(spec->autocfg.line_out_type);
5322		alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5323	}
5324}
5325
5326static void alc880_auto_init_extra_out(struct hda_codec *codec)
5327{
5328	struct alc_spec *spec = codec->spec;
5329	hda_nid_t pin;
5330
5331	pin = spec->autocfg.speaker_pins[0];
5332	if (pin) /* connect to front */
5333		alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5334	pin = spec->autocfg.hp_pins[0];
5335	if (pin) /* connect to front */
5336		alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5337}
5338
5339static void alc880_auto_init_analog_input(struct hda_codec *codec)
5340{
5341	struct alc_spec *spec = codec->spec;
5342	struct auto_pin_cfg *cfg = &spec->autocfg;
5343	int i;
5344
5345	for (i = 0; i < cfg->num_inputs; i++) {
5346		hda_nid_t nid = cfg->inputs[i].pin;
5347		if (alc_is_input_pin(codec, nid)) {
5348			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
5349			if (nid != ALC880_PIN_CD_NID &&
5350			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5351				snd_hda_codec_write(codec, nid, 0,
5352						    AC_VERB_SET_AMP_GAIN_MUTE,
5353						    AMP_OUT_MUTE);
5354		}
5355	}
5356}
5357
5358static void alc880_auto_init_input_src(struct hda_codec *codec)
5359{
5360	struct alc_spec *spec = codec->spec;
5361	int c;
5362
5363	for (c = 0; c < spec->num_adc_nids; c++) {
5364		unsigned int mux_idx;
5365		const struct hda_input_mux *imux;
5366		mux_idx = c >= spec->num_mux_defs ? 0 : c;
5367		imux = &spec->input_mux[mux_idx];
5368		if (!imux->num_items && mux_idx > 0)
5369			imux = &spec->input_mux[0];
5370		if (imux)
5371			snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5372					    AC_VERB_SET_CONNECT_SEL,
5373					    imux->items[0].index);
5374	}
5375}
5376
5377/* parse the BIOS configuration and set up the alc_spec */
5378/* return 1 if successful, 0 if the proper config is not found,
5379 * or a negative error code
5380 */
5381static int alc880_parse_auto_config(struct hda_codec *codec)
5382{
5383	struct alc_spec *spec = codec->spec;
5384	int err;
5385	static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5386
5387	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5388					   alc880_ignore);
5389	if (err < 0)
5390		return err;
5391	if (!spec->autocfg.line_outs)
5392		return 0; /* can't find valid BIOS pin config */
5393
5394	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5395	if (err < 0)
5396		return err;
5397	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5398	if (err < 0)
5399		return err;
5400	err = alc880_auto_create_extra_out(spec,
5401					   spec->autocfg.speaker_pins[0],
5402					   "Speaker");
5403	if (err < 0)
5404		return err;
5405	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5406					   "Headphone");
5407	if (err < 0)
5408		return err;
5409	err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5410	if (err < 0)
5411		return err;
5412
5413	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5414
5415	alc_auto_parse_digital(codec);
5416
5417	if (spec->kctls.list)
5418		add_mixer(spec, spec->kctls.list);
5419
5420	add_verb(spec, alc880_volume_init_verbs);
5421
5422	spec->num_mux_defs = 1;
5423	spec->input_mux = &spec->private_imux[0];
5424
5425	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5426
5427	return 1;
5428}
5429
5430/* additional initialization for auto-configuration model */
5431static void alc880_auto_init(struct hda_codec *codec)
5432{
5433	struct alc_spec *spec = codec->spec;
5434	alc880_auto_init_multi_out(codec);
5435	alc880_auto_init_extra_out(codec);
5436	alc880_auto_init_analog_input(codec);
5437	alc880_auto_init_input_src(codec);
5438	alc_auto_init_digital(codec);
5439	if (spec->unsol_event)
5440		alc_inithook(codec);
5441}
5442
5443/* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5444 * one of two digital mic pins, e.g. on ALC272
5445 */
5446static void fixup_automic_adc(struct hda_codec *codec)
5447{
5448	struct alc_spec *spec = codec->spec;
5449	int i;
5450
5451	for (i = 0; i < spec->num_adc_nids; i++) {
5452		hda_nid_t cap = spec->capsrc_nids ?
5453			spec->capsrc_nids[i] : spec->adc_nids[i];
5454		int iidx, eidx;
5455
5456		iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5457		if (iidx < 0)
5458			continue;
5459		eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5460		if (eidx < 0)
5461			continue;
5462		spec->int_mic.mux_idx = iidx;
5463		spec->ext_mic.mux_idx = eidx;
5464		if (spec->capsrc_nids)
5465			spec->capsrc_nids += i;
5466		spec->adc_nids += i;
5467		spec->num_adc_nids = 1;
5468		return;
5469	}
5470	snd_printd(KERN_INFO "hda_codec: %s: "
5471		   "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5472		   codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5473	spec->auto_mic = 0; /* disable auto-mic to be sure */
5474}
5475
5476/* select or unmute the given capsrc route */
5477static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5478				    int idx)
5479{
5480	if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5481		snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5482					 HDA_AMP_MUTE, 0);
5483	} else {
5484		snd_hda_codec_write_cache(codec, cap, 0,
5485					  AC_VERB_SET_CONNECT_SEL, idx);
5486	}
5487}
5488
5489/* set the default connection to that pin */
5490static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5491{
5492	struct alc_spec *spec = codec->spec;
5493	int i;
5494
5495	for (i = 0; i < spec->num_adc_nids; i++) {
5496		hda_nid_t cap = spec->capsrc_nids ?
5497			spec->capsrc_nids[i] : spec->adc_nids[i];
5498		int idx;
5499
5500		idx = get_connection_index(codec, cap, pin);
5501		if (idx < 0)
5502			continue;
5503		select_or_unmute_capsrc(codec, cap, idx);
5504		return i; /* return the found index */
5505	}
5506	return -1; /* not found */
5507}
5508
5509/* choose the ADC/MUX containing the input pin and initialize the setup */
5510static void fixup_single_adc(struct hda_codec *codec)
5511{
5512	struct alc_spec *spec = codec->spec;
5513	struct auto_pin_cfg *cfg = &spec->autocfg;
5514	int i;
5515
5516	/* search for the input pin; there must be only one */
5517	if (cfg->num_inputs != 1)
5518		return;
5519	i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5520	if (i >= 0) {
5521		/* use only this ADC */
5522		if (spec->capsrc_nids)
5523			spec->capsrc_nids += i;
5524		spec->adc_nids += i;
5525		spec->num_adc_nids = 1;
5526		spec->single_input_src = 1;
5527	}
5528}
5529
5530/* initialize dual adcs */
5531static void fixup_dual_adc_switch(struct hda_codec *codec)
5532{
5533	struct alc_spec *spec = codec->spec;
5534	init_capsrc_for_pin(codec, spec->ext_mic.pin);
5535	init_capsrc_for_pin(codec, spec->int_mic.pin);
5536}
5537
5538/* initialize some special cases for input sources */
5539static void alc_init_special_input_src(struct hda_codec *codec)
5540{
5541	struct alc_spec *spec = codec->spec;
5542	if (spec->dual_adc_switch)
5543		fixup_dual_adc_switch(codec);
5544	else if (spec->single_input_src)
5545		init_capsrc_for_pin(codec, spec->autocfg.inputs[0].pin);
5546}
5547
5548static void set_capture_mixer(struct hda_codec *codec)
5549{
5550	struct alc_spec *spec = codec->spec;
5551	static struct snd_kcontrol_new *caps[2][3] = {
5552		{ alc_capture_mixer_nosrc1,
5553		  alc_capture_mixer_nosrc2,
5554		  alc_capture_mixer_nosrc3 },
5555		{ alc_capture_mixer1,
5556		  alc_capture_mixer2,
5557		  alc_capture_mixer3 },
5558	};
5559	if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5560		int mux = 0;
5561		int num_adcs = spec->num_adc_nids;
5562		if (spec->dual_adc_switch)
5563			num_adcs = 1;
5564		else if (spec->auto_mic)
5565			fixup_automic_adc(codec);
5566		else if (spec->input_mux) {
5567			if (spec->input_mux->num_items > 1)
5568				mux = 1;
5569			else if (spec->input_mux->num_items == 1)
5570				fixup_single_adc(codec);
5571		}
5572		spec->cap_mixer = caps[mux][num_adcs - 1];
5573	}
5574}
5575
5576/* fill adc_nids (and capsrc_nids) containing all active input pins */
5577static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5578				 int num_nids)
5579{
5580	struct alc_spec *spec = codec->spec;
5581	struct auto_pin_cfg *cfg = &spec->autocfg;
5582	int n;
5583	hda_nid_t fallback_adc = 0, fallback_cap = 0;
5584
5585	for (n = 0; n < num_nids; n++) {
5586		hda_nid_t adc, cap;
5587		hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5588		int nconns, i, j;
5589
5590		adc = nids[n];
5591		if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5592			continue;
5593		cap = adc;
5594		nconns = snd_hda_get_connections(codec, cap, conn,
5595						 ARRAY_SIZE(conn));
5596		if (nconns == 1) {
5597			cap = conn[0];
5598			nconns = snd_hda_get_connections(codec, cap, conn,
5599							 ARRAY_SIZE(conn));
5600		}
5601		if (nconns <= 0)
5602			continue;
5603		if (!fallback_adc) {
5604			fallback_adc = adc;
5605			fallback_cap = cap;
5606		}
5607		for (i = 0; i < cfg->num_inputs; i++) {
5608			hda_nid_t nid = cfg->inputs[i].pin;
5609			for (j = 0; j < nconns; j++) {
5610				if (conn[j] == nid)
5611					break;
5612			}
5613			if (j >= nconns)
5614				break;
5615		}
5616		if (i >= cfg->num_inputs) {
5617			int num_adcs = spec->num_adc_nids;
5618			spec->private_adc_nids[num_adcs] = adc;
5619			spec->private_capsrc_nids[num_adcs] = cap;
5620			spec->num_adc_nids++;
5621			spec->adc_nids = spec->private_adc_nids;
5622			if (adc != cap)
5623				spec->capsrc_nids = spec->private_capsrc_nids;
5624		}
5625	}
5626	if (!spec->num_adc_nids) {
5627		printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5628		       " using fallback 0x%x\n",
5629		       codec->chip_name, fallback_adc);
5630		spec->private_adc_nids[0] = fallback_adc;
5631		spec->adc_nids = spec->private_adc_nids;
5632		if (fallback_adc != fallback_cap) {
5633			spec->private_capsrc_nids[0] = fallback_cap;
5634			spec->capsrc_nids = spec->private_adc_nids;
5635		}
5636	}
5637}
5638
5639#ifdef CONFIG_SND_HDA_INPUT_BEEP
5640#define set_beep_amp(spec, nid, idx, dir) \
5641	((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5642
5643static struct snd_pci_quirk beep_white_list[] = {
5644	SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5645	SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5646	SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5647	{}
5648};
5649
5650static inline int has_cdefine_beep(struct hda_codec *codec)
5651{
5652	struct alc_spec *spec = codec->spec;
5653	const struct snd_pci_quirk *q;
5654	q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5655	if (q)
5656		return q->value;
5657	return spec->cdefine.enable_pcbeep;
5658}
5659#else
5660#define set_beep_amp(spec, nid, idx, dir) /* NOP */
5661#define has_cdefine_beep(codec)		0
5662#endif
5663
5664/*
5665 * OK, here we have finally the patch for ALC880
5666 */
5667
5668static int patch_alc880(struct hda_codec *codec)
5669{
5670	struct alc_spec *spec;
5671	int board_config;
5672	int err;
5673
5674	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5675	if (spec == NULL)
5676		return -ENOMEM;
5677
5678	codec->spec = spec;
5679
5680	board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5681						  alc880_models,
5682						  alc880_cfg_tbl);
5683	if (board_config < 0) {
5684		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5685		       codec->chip_name);
5686		board_config = ALC880_AUTO;
5687	}
5688
5689	if (board_config == ALC880_AUTO) {
5690		/* automatic parse from the BIOS config */
5691		err = alc880_parse_auto_config(codec);
5692		if (err < 0) {
5693			alc_free(codec);
5694			return err;
5695		} else if (!err) {
5696			printk(KERN_INFO
5697			       "hda_codec: Cannot set up configuration "
5698			       "from BIOS.  Using 3-stack mode...\n");
5699			board_config = ALC880_3ST;
5700		}
5701	}
5702
5703	err = snd_hda_attach_beep_device(codec, 0x1);
5704	if (err < 0) {
5705		alc_free(codec);
5706		return err;
5707	}
5708
5709	if (board_config != ALC880_AUTO)
5710		setup_preset(codec, &alc880_presets[board_config]);
5711
5712	spec->stream_analog_playback = &alc880_pcm_analog_playback;
5713	spec->stream_analog_capture = &alc880_pcm_analog_capture;
5714	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5715
5716	spec->stream_digital_playback = &alc880_pcm_digital_playback;
5717	spec->stream_digital_capture = &alc880_pcm_digital_capture;
5718
5719	if (!spec->adc_nids && spec->input_mux) {
5720		/* check whether NID 0x07 is valid */
5721		unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5722		/* get type */
5723		wcap = get_wcaps_type(wcap);
5724		if (wcap != AC_WID_AUD_IN) {
5725			spec->adc_nids = alc880_adc_nids_alt;
5726			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5727		} else {
5728			spec->adc_nids = alc880_adc_nids;
5729			spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5730		}
5731	}
5732	set_capture_mixer(codec);
5733	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5734
5735	spec->vmaster_nid = 0x0c;
5736
5737	codec->patch_ops = alc_patch_ops;
5738	if (board_config == ALC880_AUTO)
5739		spec->init_hook = alc880_auto_init;
5740#ifdef CONFIG_SND_HDA_POWER_SAVE
5741	if (!spec->loopback.amplist)
5742		spec->loopback.amplist = alc880_loopbacks;
5743#endif
5744
5745	return 0;
5746}
5747
5748
5749/*
5750 * ALC260 support
5751 */
5752
5753static hda_nid_t alc260_dac_nids[1] = {
5754	/* front */
5755	0x02,
5756};
5757
5758static hda_nid_t alc260_adc_nids[1] = {
5759	/* ADC0 */
5760	0x04,
5761};
5762
5763static hda_nid_t alc260_adc_nids_alt[1] = {
5764	/* ADC1 */
5765	0x05,
5766};
5767
5768/* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5769 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5770 */
5771static hda_nid_t alc260_dual_adc_nids[2] = {
5772	/* ADC0, ADC1 */
5773	0x04, 0x05
5774};
5775
5776#define ALC260_DIGOUT_NID	0x03
5777#define ALC260_DIGIN_NID	0x06
5778
5779static struct hda_input_mux alc260_capture_source = {
5780	.num_items = 4,
5781	.items = {
5782		{ "Mic", 0x0 },
5783		{ "Front Mic", 0x1 },
5784		{ "Line", 0x2 },
5785		{ "CD", 0x4 },
5786	},
5787};
5788
5789/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5790 * headphone jack and the internal CD lines since these are the only pins at
5791 * which audio can appear.  For flexibility, also allow the option of
5792 * recording the mixer output on the second ADC (ADC0 doesn't have a
5793 * connection to the mixer output).
5794 */
5795static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5796	{
5797		.num_items = 3,
5798		.items = {
5799			{ "Mic/Line", 0x0 },
5800			{ "CD", 0x4 },
5801			{ "Headphone", 0x2 },
5802		},
5803	},
5804	{
5805		.num_items = 4,
5806		.items = {
5807			{ "Mic/Line", 0x0 },
5808			{ "CD", 0x4 },
5809			{ "Headphone", 0x2 },
5810			{ "Mixer", 0x5 },
5811		},
5812	},
5813
5814};
5815
5816/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5817 * the Fujitsu S702x, but jacks are marked differently.
5818 */
5819static struct hda_input_mux alc260_acer_capture_sources[2] = {
5820	{
5821		.num_items = 4,
5822		.items = {
5823			{ "Mic", 0x0 },
5824			{ "Line", 0x2 },
5825			{ "CD", 0x4 },
5826			{ "Headphone", 0x5 },
5827		},
5828	},
5829	{
5830		.num_items = 5,
5831		.items = {
5832			{ "Mic", 0x0 },
5833			{ "Line", 0x2 },
5834			{ "CD", 0x4 },
5835			{ "Headphone", 0x6 },
5836			{ "Mixer", 0x5 },
5837		},
5838	},
5839};
5840
5841/* Maxdata Favorit 100XS */
5842static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5843	{
5844		.num_items = 2,
5845		.items = {
5846			{ "Line/Mic", 0x0 },
5847			{ "CD", 0x4 },
5848		},
5849	},
5850	{
5851		.num_items = 3,
5852		.items = {
5853			{ "Line/Mic", 0x0 },
5854			{ "CD", 0x4 },
5855			{ "Mixer", 0x5 },
5856		},
5857	},
5858};
5859
5860/*
5861 * This is just place-holder, so there's something for alc_build_pcms to look
5862 * at when it calculates the maximum number of channels. ALC260 has no mixer
5863 * element which allows changing the channel mode, so the verb list is
5864 * never used.
5865 */
5866static struct hda_channel_mode alc260_modes[1] = {
5867	{ 2, NULL },
5868};
5869
5870
5871/* Mixer combinations
5872 *
5873 * basic: base_output + input + pc_beep + capture
5874 * HP: base_output + input + capture_alt
5875 * HP_3013: hp_3013 + input + capture
5876 * fujitsu: fujitsu + capture
5877 * acer: acer + capture
5878 */
5879
5880static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5881	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5882	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5883	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5884	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5885	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5886	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5887	{ } /* end */
5888};
5889
5890static struct snd_kcontrol_new alc260_input_mixer[] = {
5891	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5892	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5893	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5894	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5895	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5896	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5897	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5898	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5899	{ } /* end */
5900};
5901
5902/* update HP, line and mono out pins according to the master switch */
5903static void alc260_hp_master_update(struct hda_codec *codec,
5904				    hda_nid_t hp, hda_nid_t line,
5905				    hda_nid_t mono)
5906{
5907	struct alc_spec *spec = codec->spec;
5908	unsigned int val = spec->master_sw ? PIN_HP : 0;
5909	/* change HP and line-out pins */
5910	snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5911			    val);
5912	snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5913			    val);
5914	/* mono (speaker) depending on the HP jack sense */
5915	val = (val && !spec->jack_present) ? PIN_OUT : 0;
5916	snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5917			    val);
5918}
5919
5920static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5921				   struct snd_ctl_elem_value *ucontrol)
5922{
5923	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5924	struct alc_spec *spec = codec->spec;
5925	*ucontrol->value.integer.value = spec->master_sw;
5926	return 0;
5927}
5928
5929static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5930				   struct snd_ctl_elem_value *ucontrol)
5931{
5932	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5933	struct alc_spec *spec = codec->spec;
5934	int val = !!*ucontrol->value.integer.value;
5935	hda_nid_t hp, line, mono;
5936
5937	if (val == spec->master_sw)
5938		return 0;
5939	spec->master_sw = val;
5940	hp = (kcontrol->private_value >> 16) & 0xff;
5941	line = (kcontrol->private_value >> 8) & 0xff;
5942	mono = kcontrol->private_value & 0xff;
5943	alc260_hp_master_update(codec, hp, line, mono);
5944	return 1;
5945}
5946
5947static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5948	{
5949		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5950		.name = "Master Playback Switch",
5951		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5952		.info = snd_ctl_boolean_mono_info,
5953		.get = alc260_hp_master_sw_get,
5954		.put = alc260_hp_master_sw_put,
5955		.private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5956	},
5957	HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5958	HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5959	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5960	HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5961	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5962			      HDA_OUTPUT),
5963	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5964	{ } /* end */
5965};
5966
5967static struct hda_verb alc260_hp_unsol_verbs[] = {
5968	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5969	{},
5970};
5971
5972static void alc260_hp_automute(struct hda_codec *codec)
5973{
5974	struct alc_spec *spec = codec->spec;
5975
5976	spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5977	alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5978}
5979
5980static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5981{
5982	if ((res >> 26) == ALC880_HP_EVENT)
5983		alc260_hp_automute(codec);
5984}
5985
5986static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5987	{
5988		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5989		.name = "Master Playback Switch",
5990		.subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5991		.info = snd_ctl_boolean_mono_info,
5992		.get = alc260_hp_master_sw_get,
5993		.put = alc260_hp_master_sw_put,
5994		.private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5995	},
5996	HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5997	HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5998	HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5999	HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
6000	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6001	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6002	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6003	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
6004	{ } /* end */
6005};
6006
6007static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
6008	.ops = &snd_hda_bind_vol,
6009	.values = {
6010		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
6011		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
6012		HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
6013		0
6014	},
6015};
6016
6017static struct hda_bind_ctls alc260_dc7600_bind_switch = {
6018	.ops = &snd_hda_bind_sw,
6019	.values = {
6020		HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
6021		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
6022		0
6023	},
6024};
6025
6026static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
6027	HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
6028	HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
6029	HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
6030	HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
6031	{ } /* end */
6032};
6033
6034static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
6035	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6036	{},
6037};
6038
6039static void alc260_hp_3013_automute(struct hda_codec *codec)
6040{
6041	struct alc_spec *spec = codec->spec;
6042
6043	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
6044	alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
6045}
6046
6047static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
6048				       unsigned int res)
6049{
6050	if ((res >> 26) == ALC880_HP_EVENT)
6051		alc260_hp_3013_automute(codec);
6052}
6053
6054static void alc260_hp_3012_automute(struct hda_codec *codec)
6055{
6056	unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
6057
6058	snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6059			    bits);
6060	snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6061			    bits);
6062	snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
6063			    bits);
6064}
6065
6066static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
6067				       unsigned int res)
6068{
6069	if ((res >> 26) == ALC880_HP_EVENT)
6070		alc260_hp_3012_automute(codec);
6071}
6072
6073/* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
6074 * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
6075 */
6076static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
6077	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6078	HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
6079	ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6080	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6081	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6082	HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
6083	HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
6084	ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
6085	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6086	HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
6087	{ } /* end */
6088};
6089
6090/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
6091 * versions of the ALC260 don't act on requests to enable mic bias from NID
6092 * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
6093 * datasheet doesn't mention this restriction.  At this stage it's not clear
6094 * whether this behaviour is intentional or is a hardware bug in chip
6095 * revisions available in early 2006.  Therefore for now allow the
6096 * "Headphone Jack Mode" control to span all choices, but if it turns out
6097 * that the lack of mic bias for this NID is intentional we could change the
6098 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6099 *
6100 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
6101 * don't appear to make the mic bias available from the "line" jack, even
6102 * though the NID used for this jack (0x14) can supply it.  The theory is
6103 * that perhaps Acer have included blocking capacitors between the ALC260
6104 * and the output jack.  If this turns out to be the case for all such
6105 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
6106 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
6107 *
6108 * The C20x Tablet series have a mono internal speaker which is controlled
6109 * via the chip's Mono sum widget and pin complex, so include the necessary
6110 * controls for such models.  On models without a "mono speaker" the control
6111 * won't do anything.
6112 */
6113static struct snd_kcontrol_new alc260_acer_mixer[] = {
6114	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6115	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6116	ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6117	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
6118			      HDA_OUTPUT),
6119	HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
6120			   HDA_INPUT),
6121	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6122	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6123	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6124	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6125	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6126	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6127	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6128	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6129	{ } /* end */
6130};
6131
6132/* Maxdata Favorit 100XS: one output and one input (0x12) jack
6133 */
6134static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
6135	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6136	HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
6137	ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
6138	HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6139	HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6140	ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6141	{ } /* end */
6142};
6143
6144/* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
6145 * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
6146 */
6147static struct snd_kcontrol_new alc260_will_mixer[] = {
6148	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6149	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6150	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6151	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6152	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6153	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6154	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6155	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6156	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6157	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6158	{ } /* end */
6159};
6160
6161/* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
6162 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
6163 */
6164static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
6165	HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6166	HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
6167	HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
6168	HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
6169	ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
6170	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
6171	HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
6172	HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
6173	HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
6174	ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
6175	{ } /* end */
6176};
6177
6178/*
6179 * initialization verbs
6180 */
6181static struct hda_verb alc260_init_verbs[] = {
6182	/* Line In pin widget for input */
6183	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6184	/* CD pin widget for input */
6185	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6186	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6187	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6188	/* Mic2 (front panel) pin widget for input and vref at 80% */
6189	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6190	/* LINE-2 is used for line-out in rear */
6191	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6192	/* select line-out */
6193	{0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
6194	/* LINE-OUT pin */
6195	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6196	/* enable HP */
6197	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6198	/* enable Mono */
6199	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6200	/* mute capture amp left and right */
6201	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6202	/* set connection select to line in (default select for this ADC) */
6203	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6204	/* mute capture amp left and right */
6205	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6206	/* set connection select to line in (default select for this ADC) */
6207	{0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
6208	/* set vol=0 Line-Out mixer amp left and right */
6209	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6210	/* unmute pin widget amp left and right (no gain on this amp) */
6211	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6212	/* set vol=0 HP mixer amp left and right */
6213	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6214	/* unmute pin widget amp left and right (no gain on this amp) */
6215	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6216	/* set vol=0 Mono mixer amp left and right */
6217	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6218	/* unmute pin widget amp left and right (no gain on this amp) */
6219	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6220	/* unmute LINE-2 out pin */
6221	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6222	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6223	 * Line In 2 = 0x03
6224	 */
6225	/* mute analog inputs */
6226	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6227	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6228	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6229	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6230	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6231	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6232	/* mute Front out path */
6233	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6234	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6235	/* mute Headphone out path */
6236	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6237	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6238	/* mute Mono out path */
6239	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6240	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6241	{ }
6242};
6243
6244#if 0 /* should be identical with alc260_init_verbs? */
6245static struct hda_verb alc260_hp_init_verbs[] = {
6246	/* Headphone and output */
6247	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6248	/* mono output */
6249	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6250	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6251	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6252	/* Mic2 (front panel) pin widget for input and vref at 80% */
6253	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6254	/* Line In pin widget for input */
6255	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6256	/* Line-2 pin widget for output */
6257	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6258	/* CD pin widget for input */
6259	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6260	/* unmute amp left and right */
6261	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6262	/* set connection select to line in (default select for this ADC) */
6263	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6264	/* unmute Line-Out mixer amp left and right (volume = 0) */
6265	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6266	/* mute pin widget amp left and right (no gain on this amp) */
6267	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6268	/* unmute HP mixer amp left and right (volume = 0) */
6269	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6270	/* mute pin widget amp left and right (no gain on this amp) */
6271	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6272	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6273	 * Line In 2 = 0x03
6274	 */
6275	/* mute analog inputs */
6276	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6277	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6278	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6279	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6280	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6281	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6282	/* Unmute Front out path */
6283	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6284	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6285	/* Unmute Headphone out path */
6286	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6287	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6288	/* Unmute Mono out path */
6289	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6290	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6291	{ }
6292};
6293#endif
6294
6295static struct hda_verb alc260_hp_3013_init_verbs[] = {
6296	/* Line out and output */
6297	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6298	/* mono output */
6299	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6300	/* Mic1 (rear panel) pin widget for input and vref at 80% */
6301	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6302	/* Mic2 (front panel) pin widget for input and vref at 80% */
6303	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6304	/* Line In pin widget for input */
6305	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6306	/* Headphone pin widget for output */
6307	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6308	/* CD pin widget for input */
6309	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6310	/* unmute amp left and right */
6311	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6312	/* set connection select to line in (default select for this ADC) */
6313	{0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6314	/* unmute Line-Out mixer amp left and right (volume = 0) */
6315	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6316	/* mute pin widget amp left and right (no gain on this amp) */
6317	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6318	/* unmute HP mixer amp left and right (volume = 0) */
6319	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6320	/* mute pin widget amp left and right (no gain on this amp) */
6321	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6322	/* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6323	 * Line In 2 = 0x03
6324	 */
6325	/* mute analog inputs */
6326	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6327	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6328	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6329	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6330	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6331	/* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6332	/* Unmute Front out path */
6333	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6334	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6335	/* Unmute Headphone out path */
6336	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6337	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6338	/* Unmute Mono out path */
6339	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6340	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6341	{ }
6342};
6343
6344/* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6345 * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6346 * audio = 0x16, internal speaker = 0x10.
6347 */
6348static struct hda_verb alc260_fujitsu_init_verbs[] = {
6349	/* Disable all GPIOs */
6350	{0x01, AC_VERB_SET_GPIO_MASK, 0},
6351	/* Internal speaker is connected to headphone pin */
6352	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6353	/* Headphone/Line-out jack connects to Line1 pin; make it an output */
6354	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6355	/* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6356	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6357	/* Ensure all other unused pins are disabled and muted. */
6358	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6359	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6360	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6361	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6362	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6363	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6364	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6365	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6366
6367	/* Disable digital (SPDIF) pins */
6368	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6369	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6370
6371	/* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6372	 * when acting as an output.
6373	 */
6374	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6375
6376	/* Start with output sum widgets muted and their output gains at min */
6377	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6378	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6379	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6380	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6381	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6382	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6383	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6384	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6385	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6386
6387	/* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6388	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6389	/* Unmute Line1 pin widget output buffer since it starts as an output.
6390	 * If the pin mode is changed by the user the pin mode control will
6391	 * take care of enabling the pin's input/output buffers as needed.
6392	 * Therefore there's no need to enable the input buffer at this
6393	 * stage.
6394	 */
6395	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6396	/* Unmute input buffer of pin widget used for Line-in (no equiv
6397	 * mixer ctrl)
6398	 */
6399	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6400
6401	/* Mute capture amp left and right */
6402	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6403	/* Set ADC connection select to match default mixer setting - line
6404	 * in (on mic1 pin)
6405	 */
6406	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6407
6408	/* Do the same for the second ADC: mute capture input amp and
6409	 * set ADC connection to line in (on mic1 pin)
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 ALC260 as configured in Acer TravelMate and
6428 * similar laptops (adapted from Fujitsu init verbs).
6429 */
6430static struct hda_verb alc260_acer_init_verbs[] = {
6431	/* On TravelMate laptops, GPIO 0 enables the internal speaker and
6432	 * the headphone jack.  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	/* Internal speaker/Headphone jack is connected to Line-out pin */
6439	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6440	/* Internal microphone/Mic jack is connected to Mic1 pin */
6441	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6442	/* Line In jack is connected to Line1 pin */
6443	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6444	/* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6445	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6446	/* Ensure all other unused pins are disabled and muted. */
6447	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6448	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6449	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6450	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6451	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6452	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6453	/* Disable digital (SPDIF) pins */
6454	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6455	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6456
6457	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6458	 * bus when acting as outputs.
6459	 */
6460	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6461	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6462
6463	/* Start with output sum widgets muted and their output gains at min */
6464	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6465	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6466	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6467	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6468	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6469	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6470	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6471	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6472	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6473
6474	/* Unmute Line-out pin widget amp left and right
6475	 * (no equiv mixer ctrl)
6476	 */
6477	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6478	/* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6479	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6480	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
6481	 * inputs. If the pin mode is changed by the user the pin mode control
6482	 * will take care of enabling the pin's input/output buffers as needed.
6483	 * Therefore there's no need to enable the input buffer at this
6484	 * stage.
6485	 */
6486	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6487	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6488
6489	/* Mute capture amp left and right */
6490	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6491	/* Set ADC connection select to match default mixer setting - mic
6492	 * (on mic1 pin)
6493	 */
6494	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6495
6496	/* Do similar with the second ADC: mute capture input amp and
6497	 * set ADC connection to mic to match ALSA's default state.
6498	 */
6499	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6500	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6501
6502	/* Mute all inputs to mixer widget (even unconnected ones) */
6503	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6504	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6505	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6506	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6507	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6508	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6509	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6510	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6511
6512	{ }
6513};
6514
6515/* Initialisation sequence for Maxdata Favorit 100XS
6516 * (adapted from Acer init verbs).
6517 */
6518static struct hda_verb alc260_favorit100_init_verbs[] = {
6519	/* GPIO 0 enables the output jack.
6520	 * Turn this on and rely on the standard mute
6521	 * methods whenever the user wants to turn these outputs off.
6522	 */
6523	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6524	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6525	{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6526	/* Line/Mic input jack is connected to Mic1 pin */
6527	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6528	/* Ensure all other unused pins are disabled and muted. */
6529	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6530	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6531	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6532	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6533	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6534	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6535	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6536	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6537	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6538	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6539	/* Disable digital (SPDIF) pins */
6540	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6541	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6542
6543	/* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6544	 * bus when acting as outputs.
6545	 */
6546	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6547	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6548
6549	/* Start with output sum widgets muted and their output gains at min */
6550	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6551	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6552	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6553	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6554	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6555	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6556	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6557	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6558	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6559
6560	/* Unmute Line-out pin widget amp left and right
6561	 * (no equiv mixer ctrl)
6562	 */
6563	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6564	/* Unmute Mic1 and Line1 pin widget input buffers since they start as
6565	 * inputs. If the pin mode is changed by the user the pin mode control
6566	 * will take care of enabling the pin's input/output buffers as needed.
6567	 * Therefore there's no need to enable the input buffer at this
6568	 * stage.
6569	 */
6570	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6571
6572	/* Mute capture amp left and right */
6573	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6574	/* Set ADC connection select to match default mixer setting - mic
6575	 * (on mic1 pin)
6576	 */
6577	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6578
6579	/* Do similar with the second ADC: mute capture input amp and
6580	 * set ADC connection to mic to match ALSA's default state.
6581	 */
6582	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6583	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6584
6585	/* Mute all inputs to mixer widget (even unconnected ones) */
6586	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6587	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6588	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6589	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6590	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6591	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6592	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6593	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6594
6595	{ }
6596};
6597
6598static struct hda_verb alc260_will_verbs[] = {
6599	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6600	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6601	{0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6602	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6603	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6604	{0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6605	{}
6606};
6607
6608static struct hda_verb alc260_replacer_672v_verbs[] = {
6609	{0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6610	{0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6611	{0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6612
6613	{0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6614	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6615	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6616
6617	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6618	{}
6619};
6620
6621/* toggle speaker-output according to the hp-jack state */
6622static void alc260_replacer_672v_automute(struct hda_codec *codec)
6623{
6624        unsigned int present;
6625
6626	/* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6627	present = snd_hda_jack_detect(codec, 0x0f);
6628	if (present) {
6629		snd_hda_codec_write_cache(codec, 0x01, 0,
6630					  AC_VERB_SET_GPIO_DATA, 1);
6631		snd_hda_codec_write_cache(codec, 0x0f, 0,
6632					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6633					  PIN_HP);
6634	} else {
6635		snd_hda_codec_write_cache(codec, 0x01, 0,
6636					  AC_VERB_SET_GPIO_DATA, 0);
6637		snd_hda_codec_write_cache(codec, 0x0f, 0,
6638					  AC_VERB_SET_PIN_WIDGET_CONTROL,
6639					  PIN_OUT);
6640	}
6641}
6642
6643static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6644                                       unsigned int res)
6645{
6646        if ((res >> 26) == ALC880_HP_EVENT)
6647                alc260_replacer_672v_automute(codec);
6648}
6649
6650static struct hda_verb alc260_hp_dc7600_verbs[] = {
6651	{0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6652	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6653	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6654	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6655	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6656	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6657	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6658	{0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6659	{0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6660	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6661	{}
6662};
6663
6664/* Test configuration for debugging, modelled after the ALC880 test
6665 * configuration.
6666 */
6667#ifdef CONFIG_SND_DEBUG
6668static hda_nid_t alc260_test_dac_nids[1] = {
6669	0x02,
6670};
6671static hda_nid_t alc260_test_adc_nids[2] = {
6672	0x04, 0x05,
6673};
6674/* For testing the ALC260, each input MUX needs its own definition since
6675 * the signal assignments are different.  This assumes that the first ADC
6676 * is NID 0x04.
6677 */
6678static struct hda_input_mux alc260_test_capture_sources[2] = {
6679	{
6680		.num_items = 7,
6681		.items = {
6682			{ "MIC1 pin", 0x0 },
6683			{ "MIC2 pin", 0x1 },
6684			{ "LINE1 pin", 0x2 },
6685			{ "LINE2 pin", 0x3 },
6686			{ "CD pin", 0x4 },
6687			{ "LINE-OUT pin", 0x5 },
6688			{ "HP-OUT pin", 0x6 },
6689		},
6690        },
6691	{
6692		.num_items = 8,
6693		.items = {
6694			{ "MIC1 pin", 0x0 },
6695			{ "MIC2 pin", 0x1 },
6696			{ "LINE1 pin", 0x2 },
6697			{ "LINE2 pin", 0x3 },
6698			{ "CD pin", 0x4 },
6699			{ "Mixer", 0x5 },
6700			{ "LINE-OUT pin", 0x6 },
6701			{ "HP-OUT pin", 0x7 },
6702		},
6703        },
6704};
6705static struct snd_kcontrol_new alc260_test_mixer[] = {
6706	/* Output driver widgets */
6707	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6708	HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6709	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6710	HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6711	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6712	HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6713
6714	/* Modes for retasking pin widgets
6715	 * Note: the ALC260 doesn't seem to act on requests to enable mic
6716         * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6717         * mention this restriction.  At this stage it's not clear whether
6718         * this behaviour is intentional or is a hardware bug in chip
6719         * revisions available at least up until early 2006.  Therefore for
6720         * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6721         * choices, but if it turns out that the lack of mic bias for these
6722         * NIDs is intentional we could change their modes from
6723         * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6724	 */
6725	ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6726	ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6727	ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6728	ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6729	ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6730	ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6731
6732	/* Loopback mixer controls */
6733	HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6734	HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6735	HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6736	HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6737	HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6738	HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6739	HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6740	HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6741	HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6742	HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6743	HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6744	HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6745	HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6746	HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6747
6748	/* Controls for GPIO pins, assuming they are configured as outputs */
6749	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6750	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6751	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6752	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6753
6754	/* Switches to allow the digital IO pins to be enabled.  The datasheet
6755	 * is ambigious as to which NID is which; testing on laptops which
6756	 * make this output available should provide clarification.
6757	 */
6758	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6759	ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6760
6761	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
6762	 * this output to turn on an external amplifier.
6763	 */
6764	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6765	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6766
6767	{ } /* end */
6768};
6769static struct hda_verb alc260_test_init_verbs[] = {
6770	/* Enable all GPIOs as outputs with an initial value of 0 */
6771	{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6772	{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6773	{0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6774
6775	/* Enable retasking pins as output, initially without power amp */
6776	{0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6777	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6778	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6779	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6780	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6781	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6782
6783	/* Disable digital (SPDIF) pins initially, but users can enable
6784	 * them via a mixer switch.  In the case of SPDIF-out, this initverb
6785	 * payload also sets the generation to 0, output to be in "consumer"
6786	 * PCM format, copyright asserted, no pre-emphasis and no validity
6787	 * control.
6788	 */
6789	{0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6790	{0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6791
6792	/* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6793	 * OUT1 sum bus when acting as an output.
6794	 */
6795	{0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6796	{0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6797	{0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6798	{0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6799
6800	/* Start with output sum widgets muted and their output gains at min */
6801	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6802	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6803	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6804	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6805	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6806	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6807	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6808	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6809	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6810
6811	/* Unmute retasking pin widget output buffers since the default
6812	 * state appears to be output.  As the pin mode is changed by the
6813	 * user the pin mode control will take care of enabling the pin's
6814	 * input/output buffers as needed.
6815	 */
6816	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6817	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6818	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6819	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6820	{0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6821	{0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6822	/* Also unmute the mono-out pin widget */
6823	{0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6824
6825	/* Mute capture amp left and right */
6826	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6827	/* Set ADC connection select to match default mixer setting (mic1
6828	 * pin)
6829	 */
6830	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6831
6832	/* Do the same for the second ADC: mute capture input amp and
6833	 * set ADC connection to mic1 pin
6834	 */
6835	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6836	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6837
6838	/* Mute all inputs to mixer widget (even unconnected ones) */
6839	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6840	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6841	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6842	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6843	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6844	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6845	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6846	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6847
6848	{ }
6849};
6850#endif
6851
6852#define alc260_pcm_analog_playback	alc880_pcm_analog_alt_playback
6853#define alc260_pcm_analog_capture	alc880_pcm_analog_capture
6854
6855#define alc260_pcm_digital_playback	alc880_pcm_digital_playback
6856#define alc260_pcm_digital_capture	alc880_pcm_digital_capture
6857
6858/*
6859 * for BIOS auto-configuration
6860 */
6861
6862static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6863					const char *pfx, int *vol_bits)
6864{
6865	hda_nid_t nid_vol;
6866	unsigned long vol_val, sw_val;
6867	int err;
6868
6869	if (nid >= 0x0f && nid < 0x11) {
6870		nid_vol = nid - 0x7;
6871		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6872		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6873	} else if (nid == 0x11) {
6874		nid_vol = nid - 0x7;
6875		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6876		sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6877	} else if (nid >= 0x12 && nid <= 0x15) {
6878		nid_vol = 0x08;
6879		vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6880		sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6881	} else
6882		return 0; /* N/A */
6883
6884	if (!(*vol_bits & (1 << nid_vol))) {
6885		/* first control for the volume widget */
6886		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6887		if (err < 0)
6888			return err;
6889		*vol_bits |= (1 << nid_vol);
6890	}
6891	err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6892	if (err < 0)
6893		return err;
6894	return 1;
6895}
6896
6897/* add playback controls from the parsed DAC table */
6898static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6899					     const struct auto_pin_cfg *cfg)
6900{
6901	hda_nid_t nid;
6902	int err;
6903	int vols = 0;
6904
6905	spec->multiout.num_dacs = 1;
6906	spec->multiout.dac_nids = spec->private_dac_nids;
6907	spec->multiout.dac_nids[0] = 0x02;
6908
6909	nid = cfg->line_out_pins[0];
6910	if (nid) {
6911		const char *pfx;
6912		if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6913			pfx = "Master";
6914		else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6915			pfx = "Speaker";
6916		else
6917			pfx = "Front";
6918		err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6919		if (err < 0)
6920			return err;
6921	}
6922
6923	nid = cfg->speaker_pins[0];
6924	if (nid) {
6925		err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6926		if (err < 0)
6927			return err;
6928	}
6929
6930	nid = cfg->hp_pins[0];
6931	if (nid) {
6932		err = alc260_add_playback_controls(spec, nid, "Headphone",
6933						   &vols);
6934		if (err < 0)
6935			return err;
6936	}
6937	return 0;
6938}
6939
6940/* create playback/capture controls for input pins */
6941static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6942						const struct auto_pin_cfg *cfg)
6943{
6944	return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6945}
6946
6947static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6948					      hda_nid_t nid, int pin_type,
6949					      int sel_idx)
6950{
6951	alc_set_pin_output(codec, nid, pin_type);
6952	/* need the manual connection? */
6953	if (nid >= 0x12) {
6954		int idx = nid - 0x12;
6955		snd_hda_codec_write(codec, idx + 0x0b, 0,
6956				    AC_VERB_SET_CONNECT_SEL, sel_idx);
6957	}
6958}
6959
6960static void alc260_auto_init_multi_out(struct hda_codec *codec)
6961{
6962	struct alc_spec *spec = codec->spec;
6963	hda_nid_t nid;
6964
6965	nid = spec->autocfg.line_out_pins[0];
6966	if (nid) {
6967		int pin_type = get_pin_type(spec->autocfg.line_out_type);
6968		alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6969	}
6970
6971	nid = spec->autocfg.speaker_pins[0];
6972	if (nid)
6973		alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6974
6975	nid = spec->autocfg.hp_pins[0];
6976	if (nid)
6977		alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6978}
6979
6980#define ALC260_PIN_CD_NID		0x16
6981static void alc260_auto_init_analog_input(struct hda_codec *codec)
6982{
6983	struct alc_spec *spec = codec->spec;
6984	struct auto_pin_cfg *cfg = &spec->autocfg;
6985	int i;
6986
6987	for (i = 0; i < cfg->num_inputs; i++) {
6988		hda_nid_t nid = cfg->inputs[i].pin;
6989		if (nid >= 0x12) {
6990			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
6991			if (nid != ALC260_PIN_CD_NID &&
6992			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6993				snd_hda_codec_write(codec, nid, 0,
6994						    AC_VERB_SET_AMP_GAIN_MUTE,
6995						    AMP_OUT_MUTE);
6996		}
6997	}
6998}
6999
7000#define alc260_auto_init_input_src	alc880_auto_init_input_src
7001
7002/*
7003 * generic initialization of ADC, input mixers and output mixers
7004 */
7005static struct hda_verb alc260_volume_init_verbs[] = {
7006	/*
7007	 * Unmute ADC0-1 and set the default input to mic-in
7008	 */
7009	{0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
7010	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7011	{0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
7012	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7013
7014	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7015	 * mixer widget
7016	 * Note: PASD motherboards uses the Line In 2 as the input for
7017	 * front panel mic (mic 2)
7018	 */
7019	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7020	/* mute analog inputs */
7021	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7022	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7023	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7024	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7025	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7026
7027	/*
7028	 * Set up output mixers (0x08 - 0x0a)
7029	 */
7030	/* set vol=0 to output mixers */
7031	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7032	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7033	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7034	/* set up input amps for analog loopback */
7035	/* Amp Indices: DAC = 0, mixer = 1 */
7036	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7037	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7038	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7039	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7040	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7041	{0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7042
7043	{ }
7044};
7045
7046static int alc260_parse_auto_config(struct hda_codec *codec)
7047{
7048	struct alc_spec *spec = codec->spec;
7049	int err;
7050	static hda_nid_t alc260_ignore[] = { 0x17, 0 };
7051
7052	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
7053					   alc260_ignore);
7054	if (err < 0)
7055		return err;
7056	err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
7057	if (err < 0)
7058		return err;
7059	if (!spec->kctls.list)
7060		return 0; /* can't find valid BIOS pin config */
7061	err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
7062	if (err < 0)
7063		return err;
7064
7065	spec->multiout.max_channels = 2;
7066
7067	if (spec->autocfg.dig_outs)
7068		spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
7069	if (spec->kctls.list)
7070		add_mixer(spec, spec->kctls.list);
7071
7072	add_verb(spec, alc260_volume_init_verbs);
7073
7074	spec->num_mux_defs = 1;
7075	spec->input_mux = &spec->private_imux[0];
7076
7077	alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
7078
7079	return 1;
7080}
7081
7082/* additional initialization for auto-configuration model */
7083static void alc260_auto_init(struct hda_codec *codec)
7084{
7085	struct alc_spec *spec = codec->spec;
7086	alc260_auto_init_multi_out(codec);
7087	alc260_auto_init_analog_input(codec);
7088	alc260_auto_init_input_src(codec);
7089	alc_auto_init_digital(codec);
7090	if (spec->unsol_event)
7091		alc_inithook(codec);
7092}
7093
7094#ifdef CONFIG_SND_HDA_POWER_SAVE
7095static struct hda_amp_list alc260_loopbacks[] = {
7096	{ 0x07, HDA_INPUT, 0 },
7097	{ 0x07, HDA_INPUT, 1 },
7098	{ 0x07, HDA_INPUT, 2 },
7099	{ 0x07, HDA_INPUT, 3 },
7100	{ 0x07, HDA_INPUT, 4 },
7101	{ } /* end */
7102};
7103#endif
7104
7105/*
7106 * Pin config fixes
7107 */
7108enum {
7109	PINFIX_HP_DC5750,
7110};
7111
7112static const struct alc_fixup alc260_fixups[] = {
7113	[PINFIX_HP_DC5750] = {
7114		.type = ALC_FIXUP_PINS,
7115		.v.pins = (const struct alc_pincfg[]) {
7116			{ 0x11, 0x90130110 }, /* speaker */
7117			{ }
7118		}
7119	},
7120};
7121
7122static struct snd_pci_quirk alc260_fixup_tbl[] = {
7123	SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
7124	{}
7125};
7126
7127/*
7128 * ALC260 configurations
7129 */
7130static const char * const alc260_models[ALC260_MODEL_LAST] = {
7131	[ALC260_BASIC]		= "basic",
7132	[ALC260_HP]		= "hp",
7133	[ALC260_HP_3013]	= "hp-3013",
7134	[ALC260_HP_DC7600]	= "hp-dc7600",
7135	[ALC260_FUJITSU_S702X]	= "fujitsu",
7136	[ALC260_ACER]		= "acer",
7137	[ALC260_WILL]		= "will",
7138	[ALC260_REPLACER_672V]	= "replacer",
7139	[ALC260_FAVORIT100]	= "favorit100",
7140#ifdef CONFIG_SND_DEBUG
7141	[ALC260_TEST]		= "test",
7142#endif
7143	[ALC260_AUTO]		= "auto",
7144};
7145
7146static struct snd_pci_quirk alc260_cfg_tbl[] = {
7147	SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
7148	SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
7149	SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
7150	SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
7151	SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
7152	SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
7153	SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
7154	SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
7155	SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
7156	SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
7157	SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
7158	SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
7159	SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
7160	SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
7161	SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
7162	SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
7163	SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
7164	SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
7165	SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
7166	SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
7167	{}
7168};
7169
7170static struct alc_config_preset alc260_presets[] = {
7171	[ALC260_BASIC] = {
7172		.mixers = { alc260_base_output_mixer,
7173			    alc260_input_mixer },
7174		.init_verbs = { alc260_init_verbs },
7175		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7176		.dac_nids = alc260_dac_nids,
7177		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7178		.adc_nids = alc260_dual_adc_nids,
7179		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7180		.channel_mode = alc260_modes,
7181		.input_mux = &alc260_capture_source,
7182	},
7183	[ALC260_HP] = {
7184		.mixers = { alc260_hp_output_mixer,
7185			    alc260_input_mixer },
7186		.init_verbs = { alc260_init_verbs,
7187				alc260_hp_unsol_verbs },
7188		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7189		.dac_nids = alc260_dac_nids,
7190		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7191		.adc_nids = alc260_adc_nids_alt,
7192		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7193		.channel_mode = alc260_modes,
7194		.input_mux = &alc260_capture_source,
7195		.unsol_event = alc260_hp_unsol_event,
7196		.init_hook = alc260_hp_automute,
7197	},
7198	[ALC260_HP_DC7600] = {
7199		.mixers = { alc260_hp_dc7600_mixer,
7200			    alc260_input_mixer },
7201		.init_verbs = { alc260_init_verbs,
7202				alc260_hp_dc7600_verbs },
7203		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7204		.dac_nids = alc260_dac_nids,
7205		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7206		.adc_nids = alc260_adc_nids_alt,
7207		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7208		.channel_mode = alc260_modes,
7209		.input_mux = &alc260_capture_source,
7210		.unsol_event = alc260_hp_3012_unsol_event,
7211		.init_hook = alc260_hp_3012_automute,
7212	},
7213	[ALC260_HP_3013] = {
7214		.mixers = { alc260_hp_3013_mixer,
7215			    alc260_input_mixer },
7216		.init_verbs = { alc260_hp_3013_init_verbs,
7217				alc260_hp_3013_unsol_verbs },
7218		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7219		.dac_nids = alc260_dac_nids,
7220		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
7221		.adc_nids = alc260_adc_nids_alt,
7222		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7223		.channel_mode = alc260_modes,
7224		.input_mux = &alc260_capture_source,
7225		.unsol_event = alc260_hp_3013_unsol_event,
7226		.init_hook = alc260_hp_3013_automute,
7227	},
7228	[ALC260_FUJITSU_S702X] = {
7229		.mixers = { alc260_fujitsu_mixer },
7230		.init_verbs = { alc260_fujitsu_init_verbs },
7231		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7232		.dac_nids = alc260_dac_nids,
7233		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7234		.adc_nids = alc260_dual_adc_nids,
7235		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7236		.channel_mode = alc260_modes,
7237		.num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
7238		.input_mux = alc260_fujitsu_capture_sources,
7239	},
7240	[ALC260_ACER] = {
7241		.mixers = { alc260_acer_mixer },
7242		.init_verbs = { alc260_acer_init_verbs },
7243		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7244		.dac_nids = alc260_dac_nids,
7245		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7246		.adc_nids = alc260_dual_adc_nids,
7247		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7248		.channel_mode = alc260_modes,
7249		.num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
7250		.input_mux = alc260_acer_capture_sources,
7251	},
7252	[ALC260_FAVORIT100] = {
7253		.mixers = { alc260_favorit100_mixer },
7254		.init_verbs = { alc260_favorit100_init_verbs },
7255		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7256		.dac_nids = alc260_dac_nids,
7257		.num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
7258		.adc_nids = alc260_dual_adc_nids,
7259		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7260		.channel_mode = alc260_modes,
7261		.num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
7262		.input_mux = alc260_favorit100_capture_sources,
7263	},
7264	[ALC260_WILL] = {
7265		.mixers = { alc260_will_mixer },
7266		.init_verbs = { alc260_init_verbs, alc260_will_verbs },
7267		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7268		.dac_nids = alc260_dac_nids,
7269		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7270		.adc_nids = alc260_adc_nids,
7271		.dig_out_nid = ALC260_DIGOUT_NID,
7272		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7273		.channel_mode = alc260_modes,
7274		.input_mux = &alc260_capture_source,
7275	},
7276	[ALC260_REPLACER_672V] = {
7277		.mixers = { alc260_replacer_672v_mixer },
7278		.init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
7279		.num_dacs = ARRAY_SIZE(alc260_dac_nids),
7280		.dac_nids = alc260_dac_nids,
7281		.num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
7282		.adc_nids = alc260_adc_nids,
7283		.dig_out_nid = ALC260_DIGOUT_NID,
7284		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7285		.channel_mode = alc260_modes,
7286		.input_mux = &alc260_capture_source,
7287		.unsol_event = alc260_replacer_672v_unsol_event,
7288		.init_hook = alc260_replacer_672v_automute,
7289	},
7290#ifdef CONFIG_SND_DEBUG
7291	[ALC260_TEST] = {
7292		.mixers = { alc260_test_mixer },
7293		.init_verbs = { alc260_test_init_verbs },
7294		.num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
7295		.dac_nids = alc260_test_dac_nids,
7296		.num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
7297		.adc_nids = alc260_test_adc_nids,
7298		.num_channel_mode = ARRAY_SIZE(alc260_modes),
7299		.channel_mode = alc260_modes,
7300		.num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7301		.input_mux = alc260_test_capture_sources,
7302	},
7303#endif
7304};
7305
7306static int patch_alc260(struct hda_codec *codec)
7307{
7308	struct alc_spec *spec;
7309	int err, board_config;
7310
7311	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7312	if (spec == NULL)
7313		return -ENOMEM;
7314
7315	codec->spec = spec;
7316
7317	board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7318						  alc260_models,
7319						  alc260_cfg_tbl);
7320	if (board_config < 0) {
7321		snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7322			   codec->chip_name);
7323		board_config = ALC260_AUTO;
7324	}
7325
7326	if (board_config == ALC260_AUTO) {
7327		alc_pick_fixup(codec, NULL, alc260_fixup_tbl, alc260_fixups);
7328		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
7329	}
7330
7331	if (board_config == ALC260_AUTO) {
7332		/* automatic parse from the BIOS config */
7333		err = alc260_parse_auto_config(codec);
7334		if (err < 0) {
7335			alc_free(codec);
7336			return err;
7337		} else if (!err) {
7338			printk(KERN_INFO
7339			       "hda_codec: Cannot set up configuration "
7340			       "from BIOS.  Using base mode...\n");
7341			board_config = ALC260_BASIC;
7342		}
7343	}
7344
7345	err = snd_hda_attach_beep_device(codec, 0x1);
7346	if (err < 0) {
7347		alc_free(codec);
7348		return err;
7349	}
7350
7351	if (board_config != ALC260_AUTO)
7352		setup_preset(codec, &alc260_presets[board_config]);
7353
7354	spec->stream_analog_playback = &alc260_pcm_analog_playback;
7355	spec->stream_analog_capture = &alc260_pcm_analog_capture;
7356	spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7357
7358	spec->stream_digital_playback = &alc260_pcm_digital_playback;
7359	spec->stream_digital_capture = &alc260_pcm_digital_capture;
7360
7361	if (!spec->adc_nids && spec->input_mux) {
7362		/* check whether NID 0x04 is valid */
7363		unsigned int wcap = get_wcaps(codec, 0x04);
7364		wcap = get_wcaps_type(wcap);
7365		/* get type */
7366		if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7367			spec->adc_nids = alc260_adc_nids_alt;
7368			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7369		} else {
7370			spec->adc_nids = alc260_adc_nids;
7371			spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7372		}
7373	}
7374	set_capture_mixer(codec);
7375	set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7376
7377	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
7378
7379	spec->vmaster_nid = 0x08;
7380
7381	codec->patch_ops = alc_patch_ops;
7382	if (board_config == ALC260_AUTO)
7383		spec->init_hook = alc260_auto_init;
7384#ifdef CONFIG_SND_HDA_POWER_SAVE
7385	if (!spec->loopback.amplist)
7386		spec->loopback.amplist = alc260_loopbacks;
7387#endif
7388
7389	return 0;
7390}
7391
7392
7393/*
7394 * ALC882/883/885/888/889 support
7395 *
7396 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7397 * configuration.  Each pin widget can choose any input DACs and a mixer.
7398 * Each ADC is connected from a mixer of all inputs.  This makes possible
7399 * 6-channel independent captures.
7400 *
7401 * In addition, an independent DAC for the multi-playback (not used in this
7402 * driver yet).
7403 */
7404#define ALC882_DIGOUT_NID	0x06
7405#define ALC882_DIGIN_NID	0x0a
7406#define ALC883_DIGOUT_NID	ALC882_DIGOUT_NID
7407#define ALC883_DIGIN_NID	ALC882_DIGIN_NID
7408#define ALC1200_DIGOUT_NID	0x10
7409
7410
7411static struct hda_channel_mode alc882_ch_modes[1] = {
7412	{ 8, NULL }
7413};
7414
7415/* DACs */
7416static hda_nid_t alc882_dac_nids[4] = {
7417	/* front, rear, clfe, rear_surr */
7418	0x02, 0x03, 0x04, 0x05
7419};
7420#define alc883_dac_nids		alc882_dac_nids
7421
7422/* ADCs */
7423#define alc882_adc_nids		alc880_adc_nids
7424#define alc882_adc_nids_alt	alc880_adc_nids_alt
7425#define alc883_adc_nids		alc882_adc_nids_alt
7426static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7427static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7428#define alc889_adc_nids		alc880_adc_nids
7429
7430static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7431static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7432#define alc883_capsrc_nids	alc882_capsrc_nids_alt
7433static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7434#define alc889_capsrc_nids	alc882_capsrc_nids
7435
7436/* input MUX */
7437/* FIXME: should be a matrix-type input source selection */
7438
7439static struct hda_input_mux alc882_capture_source = {
7440	.num_items = 4,
7441	.items = {
7442		{ "Mic", 0x0 },
7443		{ "Front Mic", 0x1 },
7444		{ "Line", 0x2 },
7445		{ "CD", 0x4 },
7446	},
7447};
7448
7449#define alc883_capture_source	alc882_capture_source
7450
7451static struct hda_input_mux alc889_capture_source = {
7452	.num_items = 3,
7453	.items = {
7454		{ "Front Mic", 0x0 },
7455		{ "Mic", 0x3 },
7456		{ "Line", 0x2 },
7457	},
7458};
7459
7460static struct hda_input_mux mb5_capture_source = {
7461	.num_items = 3,
7462	.items = {
7463		{ "Mic", 0x1 },
7464		{ "Line", 0x7 },
7465		{ "CD", 0x4 },
7466	},
7467};
7468
7469static struct hda_input_mux macmini3_capture_source = {
7470	.num_items = 2,
7471	.items = {
7472		{ "Line", 0x2 },
7473		{ "CD", 0x4 },
7474	},
7475};
7476
7477static struct hda_input_mux alc883_3stack_6ch_intel = {
7478	.num_items = 4,
7479	.items = {
7480		{ "Mic", 0x1 },
7481		{ "Front Mic", 0x0 },
7482		{ "Line", 0x2 },
7483		{ "CD", 0x4 },
7484	},
7485};
7486
7487static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7488	.num_items = 2,
7489	.items = {
7490		{ "Mic", 0x1 },
7491		{ "Line", 0x2 },
7492	},
7493};
7494
7495static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7496	.num_items = 4,
7497	.items = {
7498		{ "Mic", 0x0 },
7499		{ "Internal Mic", 0x1 },
7500		{ "Line", 0x2 },
7501		{ "CD", 0x4 },
7502	},
7503};
7504
7505static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7506	.num_items = 2,
7507	.items = {
7508		{ "Mic", 0x0 },
7509		{ "Internal Mic", 0x1 },
7510	},
7511};
7512
7513static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7514	.num_items = 3,
7515	.items = {
7516		{ "Mic", 0x0 },
7517		{ "Front Mic", 0x1 },
7518		{ "Line", 0x4 },
7519	},
7520};
7521
7522static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7523	.num_items = 2,
7524	.items = {
7525		{ "Mic", 0x0 },
7526		{ "Line", 0x2 },
7527	},
7528};
7529
7530static struct hda_input_mux alc889A_mb31_capture_source = {
7531	.num_items = 2,
7532	.items = {
7533		{ "Mic", 0x0 },
7534		/* Front Mic (0x01) unused */
7535		{ "Line", 0x2 },
7536		/* Line 2 (0x03) unused */
7537		/* CD (0x04) unused? */
7538	},
7539};
7540
7541static struct hda_input_mux alc889A_imac91_capture_source = {
7542	.num_items = 2,
7543	.items = {
7544		{ "Mic", 0x01 },
7545		{ "Line", 0x2 }, /* Not sure! */
7546	},
7547};
7548
7549/*
7550 * 2ch mode
7551 */
7552static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7553	{ 2, NULL }
7554};
7555
7556/*
7557 * 2ch mode
7558 */
7559static struct hda_verb alc882_3ST_ch2_init[] = {
7560	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7561	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7562	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7563	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7564	{ } /* end */
7565};
7566
7567/*
7568 * 4ch mode
7569 */
7570static struct hda_verb alc882_3ST_ch4_init[] = {
7571	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7572	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7573	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7574	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7575	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7576	{ } /* end */
7577};
7578
7579/*
7580 * 6ch mode
7581 */
7582static struct hda_verb alc882_3ST_ch6_init[] = {
7583	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7584	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7585	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7586	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7587	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7588	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7589	{ } /* end */
7590};
7591
7592static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7593	{ 2, alc882_3ST_ch2_init },
7594	{ 4, alc882_3ST_ch4_init },
7595	{ 6, alc882_3ST_ch6_init },
7596};
7597
7598#define alc883_3ST_6ch_modes	alc882_3ST_6ch_modes
7599
7600/*
7601 * 2ch mode
7602 */
7603static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7604	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7605	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7606	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7607	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7608	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7609	{ } /* end */
7610};
7611
7612/*
7613 * 4ch mode
7614 */
7615static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7616	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7617	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7618	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7619	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7620	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7621	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7622	{ } /* end */
7623};
7624
7625/*
7626 * 6ch mode
7627 */
7628static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7629	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7630	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7631	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7632	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7633	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7634	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7635	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7636	{ } /* end */
7637};
7638
7639static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7640	{ 2, alc883_3ST_ch2_clevo_init },
7641	{ 4, alc883_3ST_ch4_clevo_init },
7642	{ 6, alc883_3ST_ch6_clevo_init },
7643};
7644
7645
7646/*
7647 * 6ch mode
7648 */
7649static struct hda_verb alc882_sixstack_ch6_init[] = {
7650	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7651	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7652	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7653	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7654	{ } /* end */
7655};
7656
7657/*
7658 * 8ch mode
7659 */
7660static struct hda_verb alc882_sixstack_ch8_init[] = {
7661	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7662	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7663	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7664	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7665	{ } /* end */
7666};
7667
7668static struct hda_channel_mode alc882_sixstack_modes[2] = {
7669	{ 6, alc882_sixstack_ch6_init },
7670	{ 8, alc882_sixstack_ch8_init },
7671};
7672
7673
7674/* Macbook Air 2,1 */
7675
7676static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7677      { 2, NULL },
7678};
7679
7680/*
7681 * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7682 */
7683
7684/*
7685 * 2ch mode
7686 */
7687static struct hda_verb alc885_mbp_ch2_init[] = {
7688	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7689	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7690	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7691	{ } /* end */
7692};
7693
7694/*
7695 * 4ch mode
7696 */
7697static struct hda_verb alc885_mbp_ch4_init[] = {
7698	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7699	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7700	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7701	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7702	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7703	{ } /* end */
7704};
7705
7706static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7707	{ 2, alc885_mbp_ch2_init },
7708	{ 4, alc885_mbp_ch4_init },
7709};
7710
7711/*
7712 * 2ch
7713 * Speakers/Woofer/HP = Front
7714 * LineIn = Input
7715 */
7716static struct hda_verb alc885_mb5_ch2_init[] = {
7717	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7718	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7719	{ } /* end */
7720};
7721
7722/*
7723 * 6ch mode
7724 * Speakers/HP = Front
7725 * Woofer = LFE
7726 * LineIn = Surround
7727 */
7728static struct hda_verb alc885_mb5_ch6_init[] = {
7729	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7730	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7731	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7732	{ } /* end */
7733};
7734
7735static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7736	{ 2, alc885_mb5_ch2_init },
7737	{ 6, alc885_mb5_ch6_init },
7738};
7739
7740#define alc885_macmini3_6ch_modes	alc885_mb5_6ch_modes
7741
7742/*
7743 * 2ch mode
7744 */
7745static struct hda_verb alc883_4ST_ch2_init[] = {
7746	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7747	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7748	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7749	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7750	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7751	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7752	{ } /* end */
7753};
7754
7755/*
7756 * 4ch mode
7757 */
7758static struct hda_verb alc883_4ST_ch4_init[] = {
7759	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7760	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7761	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7762	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7763	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7764	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7765	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7766	{ } /* end */
7767};
7768
7769/*
7770 * 6ch mode
7771 */
7772static struct hda_verb alc883_4ST_ch6_init[] = {
7773	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7774	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7775	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7776	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7777	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7778	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7779	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7780	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7781	{ } /* end */
7782};
7783
7784/*
7785 * 8ch mode
7786 */
7787static struct hda_verb alc883_4ST_ch8_init[] = {
7788	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7789	{ 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7790	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7791	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7792	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7793	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7794	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7795	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7796	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7797	{ } /* end */
7798};
7799
7800static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7801	{ 2, alc883_4ST_ch2_init },
7802	{ 4, alc883_4ST_ch4_init },
7803	{ 6, alc883_4ST_ch6_init },
7804	{ 8, alc883_4ST_ch8_init },
7805};
7806
7807
7808/*
7809 * 2ch mode
7810 */
7811static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7812	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7813	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7814	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7815	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7816	{ } /* end */
7817};
7818
7819/*
7820 * 4ch mode
7821 */
7822static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7823	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7824	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7825	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7826	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7827	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7828	{ } /* end */
7829};
7830
7831/*
7832 * 6ch mode
7833 */
7834static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7835	{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7836	{ 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7837	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7838	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7839	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7840	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7841	{ } /* end */
7842};
7843
7844static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7845	{ 2, alc883_3ST_ch2_intel_init },
7846	{ 4, alc883_3ST_ch4_intel_init },
7847	{ 6, alc883_3ST_ch6_intel_init },
7848};
7849
7850/*
7851 * 2ch mode
7852 */
7853static struct hda_verb alc889_ch2_intel_init[] = {
7854	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7855	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7856	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7857	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7858	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7859	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7860	{ } /* end */
7861};
7862
7863/*
7864 * 6ch mode
7865 */
7866static struct hda_verb alc889_ch6_intel_init[] = {
7867	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7868	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7869	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7870	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7871	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7872	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7873	{ } /* end */
7874};
7875
7876/*
7877 * 8ch mode
7878 */
7879static struct hda_verb alc889_ch8_intel_init[] = {
7880	{ 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7881	{ 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7882	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7883	{ 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7884	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7885	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7886	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7887	{ } /* end */
7888};
7889
7890static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7891	{ 2, alc889_ch2_intel_init },
7892	{ 6, alc889_ch6_intel_init },
7893	{ 8, alc889_ch8_intel_init },
7894};
7895
7896/*
7897 * 6ch mode
7898 */
7899static struct hda_verb alc883_sixstack_ch6_init[] = {
7900	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7901	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7902	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7903	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7904	{ } /* end */
7905};
7906
7907/*
7908 * 8ch mode
7909 */
7910static struct hda_verb alc883_sixstack_ch8_init[] = {
7911	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7912	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7913	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7914	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7915	{ } /* end */
7916};
7917
7918static struct hda_channel_mode alc883_sixstack_modes[2] = {
7919	{ 6, alc883_sixstack_ch6_init },
7920	{ 8, alc883_sixstack_ch8_init },
7921};
7922
7923
7924/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7925 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7926 */
7927static struct snd_kcontrol_new alc882_base_mixer[] = {
7928	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7929	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7930	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7931	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7932	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7933	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7934	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7935	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7936	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7937	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7938	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7939	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7940	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7941	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7942	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7943	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7944	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
7945	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7946	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7947	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
7948	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7949	{ } /* end */
7950};
7951
7952/* Macbook Air 2,1 same control for HP and internal Speaker */
7953
7954static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7955      HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7956      HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7957     { }
7958};
7959
7960
7961static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7962	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7963	HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7964	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7965	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7966	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7967	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7968	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7969	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7970	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7971	HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
7972	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
7973	{ } /* end */
7974};
7975
7976static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7977	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7978	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7979	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7980	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7981	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7982	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7983	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7984	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7985	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7986	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7987	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7988	HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7989	HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
7990	HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0x00, HDA_INPUT),
7991	{ } /* end */
7992};
7993
7994static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7995	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7996	HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7997	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7998	HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7999	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
8000	HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
8001	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
8002	HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
8003	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
8004	HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
8005	HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x00, HDA_INPUT),
8006	{ } /* end */
8007};
8008
8009static struct snd_kcontrol_new alc885_imac91_mixer[] = {
8010	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8011	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
8012	{ } /* end */
8013};
8014
8015
8016static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
8017	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8018	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8019	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8020	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8021	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8022	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8023	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8024	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8025	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8026	{ } /* end */
8027};
8028
8029static struct snd_kcontrol_new alc882_targa_mixer[] = {
8030	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8031	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8032	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8033	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8034	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8035	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8036	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8037	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8038	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8039	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8040	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8041	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8042	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8043	{ } /* end */
8044};
8045
8046/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
8047 *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
8048 */
8049static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
8050	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8051	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8052	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8053	HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
8054	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8055	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8056	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8057	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8058	HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
8059	HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
8060	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8061	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8062	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8063	{ } /* end */
8064};
8065
8066static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
8067	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8068	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8069	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8070	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8071	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8072	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8073	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8074	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8075	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8076	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8077	{ } /* end */
8078};
8079
8080static struct snd_kcontrol_new alc882_chmode_mixer[] = {
8081	{
8082		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8083		.name = "Channel Mode",
8084		.info = alc_ch_mode_info,
8085		.get = alc_ch_mode_get,
8086		.put = alc_ch_mode_put,
8087	},
8088	{ } /* end */
8089};
8090
8091static struct hda_verb alc882_base_init_verbs[] = {
8092	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8093	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8094	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8095	/* Rear mixer */
8096	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8097	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8098	/* CLFE mixer */
8099	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8100	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8101	/* Side mixer */
8102	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8103	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8104
8105	/* Front Pin: output 0 (0x0c) */
8106	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8107	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8108	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8109	/* Rear Pin: output 1 (0x0d) */
8110	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8111	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8112	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8113	/* CLFE Pin: output 2 (0x0e) */
8114	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8115	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8116	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8117	/* Side Pin: output 3 (0x0f) */
8118	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8119	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8120	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8121	/* Mic (rear) pin: input vref at 80% */
8122	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8123	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8124	/* Front Mic pin: input vref at 80% */
8125	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8126	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8127	/* Line In pin: input */
8128	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8129	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8130	/* Line-2 In: Headphone output (output 0 - 0x0c) */
8131	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8132	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8133	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8134	/* CD pin widget for input */
8135	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8136
8137	/* FIXME: use matrix-type input source selection */
8138	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8139	/* Input mixer2 */
8140	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8141	/* Input mixer3 */
8142	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8143	/* ADC2: mute amp left and right */
8144	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8145	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8146	/* ADC3: mute amp left and right */
8147	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8148	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8149
8150	{ }
8151};
8152
8153static struct hda_verb alc882_adc1_init_verbs[] = {
8154	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8155	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8156	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8157	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8158	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8159	/* ADC1: mute amp left and right */
8160	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8161	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8162	{ }
8163};
8164
8165static struct hda_verb alc882_eapd_verbs[] = {
8166	/* change to EAPD mode */
8167	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8168	{0x20, AC_VERB_SET_PROC_COEF, 0x3060},
8169	{ }
8170};
8171
8172static struct hda_verb alc889_eapd_verbs[] = {
8173	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
8174	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
8175	{ }
8176};
8177
8178static struct hda_verb alc_hp15_unsol_verbs[] = {
8179	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
8180	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8181	{}
8182};
8183
8184static struct hda_verb alc885_init_verbs[] = {
8185	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8186	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8187	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8188	/* Rear mixer */
8189	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8190	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8191	/* CLFE mixer */
8192	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8193	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8194	/* Side mixer */
8195	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8196	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8197
8198	/* Front HP Pin: output 0 (0x0c) */
8199	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8200	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8201	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8202	/* Front Pin: output 0 (0x0c) */
8203	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8204	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8205	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8206	/* Rear Pin: output 1 (0x0d) */
8207	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8208	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8209	{0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
8210	/* CLFE Pin: output 2 (0x0e) */
8211	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8212	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8213	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
8214	/* Side Pin: output 3 (0x0f) */
8215	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8216	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8217	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8218	/* Mic (rear) pin: input vref at 80% */
8219	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8220	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8221	/* Front Mic pin: input vref at 80% */
8222	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8223	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8224	/* Line In pin: input */
8225	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8226	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8227
8228	/* Mixer elements: 0x18, , 0x1a, 0x1b */
8229	/* Input mixer1 */
8230	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8231	/* Input mixer2 */
8232	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8233	/* Input mixer3 */
8234	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8235	/* ADC2: mute amp left and right */
8236	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8237	/* ADC3: mute amp left and right */
8238	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8239
8240	{ }
8241};
8242
8243static struct hda_verb alc885_init_input_verbs[] = {
8244	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8245	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
8246	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
8247	{ }
8248};
8249
8250
8251/* Unmute Selector 24h and set the default input to front mic */
8252static struct hda_verb alc889_init_input_verbs[] = {
8253	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
8254	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8255	{ }
8256};
8257
8258
8259#define alc883_init_verbs	alc882_base_init_verbs
8260
8261/* Mac Pro test */
8262static struct snd_kcontrol_new alc882_macpro_mixer[] = {
8263	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8264	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8265	HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
8266	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
8267	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
8268	/* FIXME: this looks suspicious...
8269	HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
8270	HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
8271	*/
8272	{ } /* end */
8273};
8274
8275static struct hda_verb alc882_macpro_init_verbs[] = {
8276	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8277	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8278	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8279	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8280	/* Front Pin: output 0 (0x0c) */
8281	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8282	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8283	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8284	/* Front Mic pin: input vref at 80% */
8285	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8286	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8287	/* Speaker:  output */
8288	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8289	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8290	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
8291	/* Headphone output (output 0 - 0x0c) */
8292	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8293	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8294	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8295
8296	/* FIXME: use matrix-type input source selection */
8297	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8298	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8299	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8300	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8301	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8302	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8303	/* Input mixer2 */
8304	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8305	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8306	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8307	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8308	/* Input mixer3 */
8309	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8310	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8311	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8312	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8313	/* ADC1: mute amp left and right */
8314	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8315	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8316	/* ADC2: mute amp left and right */
8317	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8318	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8319	/* ADC3: mute amp left and right */
8320	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8321	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8322
8323	{ }
8324};
8325
8326/* Macbook 5,1 */
8327static struct hda_verb alc885_mb5_init_verbs[] = {
8328	/* DACs */
8329	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8330	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8331	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8332	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8333	/* Front mixer */
8334	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8335	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8336	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8337	/* Surround mixer */
8338	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8339	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8340	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8341	/* LFE mixer */
8342	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8343	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8344	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8345	/* HP mixer */
8346	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8347	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8348	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8349	/* Front Pin (0x0c) */
8350	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8351	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8352	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8353	/* LFE Pin (0x0e) */
8354	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8355	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8356	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8357	/* HP Pin (0x0f) */
8358	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8359	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8360	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8361	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8362	/* Front Mic pin: input vref at 80% */
8363	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8364	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8365	/* Line In pin */
8366	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8367	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8368
8369	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8370	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8371	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8372	{ }
8373};
8374
8375/* Macmini 3,1 */
8376static struct hda_verb alc885_macmini3_init_verbs[] = {
8377	/* DACs */
8378	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8379	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8380	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8381	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8382	/* Front mixer */
8383	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8384	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8385	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8386	/* Surround mixer */
8387	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8388	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8389	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8390	/* LFE mixer */
8391	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8392	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8393	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8394	/* HP mixer */
8395	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8396	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8397	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8398	/* Front Pin (0x0c) */
8399	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8400	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8401	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8402	/* LFE Pin (0x0e) */
8403	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8404	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8405	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8406	/* HP Pin (0x0f) */
8407	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8408	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8409	{0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8410	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8411	/* Line In pin */
8412	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8413	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8414
8415	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8416	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8417	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8418	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8419	{ }
8420};
8421
8422
8423static struct hda_verb alc885_mba21_init_verbs[] = {
8424	/*Internal and HP Speaker Mixer*/
8425	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8426	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8427	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8428	/*Internal Speaker Pin (0x0c)*/
8429	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8430	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8431	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8432	/* HP Pin: output 0 (0x0e) */
8433	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8434	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8435	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8436	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8437	/* Line in (is hp when jack connected)*/
8438	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8439	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8440
8441	{ }
8442 };
8443
8444
8445/* Macbook Pro rev3 */
8446static struct hda_verb alc885_mbp3_init_verbs[] = {
8447	/* Front mixer: unmute input/output amp left and right (volume = 0) */
8448	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8449	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8450	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8451	/* Rear mixer */
8452	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8453	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8454	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8455	/* HP mixer */
8456	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8457	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8458	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8459	/* Front Pin: output 0 (0x0c) */
8460	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8461	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8462	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8463	/* HP Pin: output 0 (0x0e) */
8464	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8465	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8466	{0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8467	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8468	/* Mic (rear) pin: input vref at 80% */
8469	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8470	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8471	/* Front Mic pin: input vref at 80% */
8472	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8473	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8474	/* Line In pin: use output 1 when in LineOut mode */
8475	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8476	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8477	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8478
8479	/* FIXME: use matrix-type input source selection */
8480	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8481	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8482	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8483	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8484	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8485	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8486	/* Input mixer2 */
8487	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8488	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8489	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8490	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8491	/* Input mixer3 */
8492	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8493	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8494	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8495	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8496	/* ADC1: mute amp left and right */
8497	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8498	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8499	/* ADC2: mute amp left and right */
8500	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8501	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8502	/* ADC3: mute amp left and right */
8503	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8504	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8505
8506	{ }
8507};
8508
8509/* iMac 9,1 */
8510static struct hda_verb alc885_imac91_init_verbs[] = {
8511	/* Internal Speaker Pin (0x0c) */
8512	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8513	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8514	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8515	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8516	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8517	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8518	/* HP Pin: Rear */
8519	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8520	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8521	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8522	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8523	/* Line in Rear */
8524	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8525	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8526	/* Front Mic pin: input vref at 80% */
8527	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8528	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8529	/* Rear mixer */
8530	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8531	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8532	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8533	/* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8534	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8535	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8536	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8537	/* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8538	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8539	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8540	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8541	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8542	/* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8543	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8544	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8545	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8546	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8547	/* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8548	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8549	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8550	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8551	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8552	/* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8553	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8554	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8555	/* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8556	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8557	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8558	/* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8559	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8560	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8561	{ }
8562};
8563
8564/* iMac 24 mixer. */
8565static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8566	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8567	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8568	{ } /* end */
8569};
8570
8571/* iMac 24 init verbs. */
8572static struct hda_verb alc885_imac24_init_verbs[] = {
8573	/* Internal speakers: output 0 (0x0c) */
8574	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8575	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8576	{0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8577	/* Internal speakers: output 0 (0x0c) */
8578	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8579	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8580	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8581	/* Headphone: output 0 (0x0c) */
8582	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8583	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8584	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8585	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8586	/* Front Mic: input vref at 80% */
8587	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8588	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8589	{ }
8590};
8591
8592/* Toggle speaker-output according to the hp-jack state */
8593static void alc885_imac24_setup(struct hda_codec *codec)
8594{
8595	struct alc_spec *spec = codec->spec;
8596
8597	spec->autocfg.hp_pins[0] = 0x14;
8598	spec->autocfg.speaker_pins[0] = 0x18;
8599	spec->autocfg.speaker_pins[1] = 0x1a;
8600}
8601
8602#define alc885_mb5_setup	alc885_imac24_setup
8603#define alc885_macmini3_setup	alc885_imac24_setup
8604
8605/* Macbook Air 2,1 */
8606static void alc885_mba21_setup(struct hda_codec *codec)
8607{
8608       struct alc_spec *spec = codec->spec;
8609
8610       spec->autocfg.hp_pins[0] = 0x14;
8611       spec->autocfg.speaker_pins[0] = 0x18;
8612}
8613
8614
8615
8616static void alc885_mbp3_setup(struct hda_codec *codec)
8617{
8618	struct alc_spec *spec = codec->spec;
8619
8620	spec->autocfg.hp_pins[0] = 0x15;
8621	spec->autocfg.speaker_pins[0] = 0x14;
8622}
8623
8624static void alc885_imac91_setup(struct hda_codec *codec)
8625{
8626	struct alc_spec *spec = codec->spec;
8627
8628	spec->autocfg.hp_pins[0] = 0x14;
8629	spec->autocfg.speaker_pins[0] = 0x18;
8630	spec->autocfg.speaker_pins[1] = 0x1a;
8631}
8632
8633static struct hda_verb alc882_targa_verbs[] = {
8634	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8635	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8636
8637	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8638	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8639
8640	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8641	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8642	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8643
8644	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8645	{ } /* end */
8646};
8647
8648/* toggle speaker-output according to the hp-jack state */
8649static void alc882_targa_automute(struct hda_codec *codec)
8650{
8651	struct alc_spec *spec = codec->spec;
8652	alc_automute_amp(codec);
8653	snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8654				  spec->jack_present ? 1 : 3);
8655}
8656
8657static void alc882_targa_setup(struct hda_codec *codec)
8658{
8659	struct alc_spec *spec = codec->spec;
8660
8661	spec->autocfg.hp_pins[0] = 0x14;
8662	spec->autocfg.speaker_pins[0] = 0x1b;
8663}
8664
8665static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8666{
8667	if ((res >> 26) == ALC880_HP_EVENT)
8668		alc882_targa_automute(codec);
8669}
8670
8671static struct hda_verb alc882_asus_a7j_verbs[] = {
8672	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8673	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8674
8675	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8676	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8677	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8678
8679	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8680	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8681	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8682
8683	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8684	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8685	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8686	{ } /* end */
8687};
8688
8689static struct hda_verb alc882_asus_a7m_verbs[] = {
8690	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8691	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8692
8693	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8694	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8695	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8696
8697	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8698	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8699	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8700
8701	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8702	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8703	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8704 	{ } /* end */
8705};
8706
8707static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8708{
8709	unsigned int gpiostate, gpiomask, gpiodir;
8710
8711	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8712				       AC_VERB_GET_GPIO_DATA, 0);
8713
8714	if (!muted)
8715		gpiostate |= (1 << pin);
8716	else
8717		gpiostate &= ~(1 << pin);
8718
8719	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8720				      AC_VERB_GET_GPIO_MASK, 0);
8721	gpiomask |= (1 << pin);
8722
8723	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8724				     AC_VERB_GET_GPIO_DIRECTION, 0);
8725	gpiodir |= (1 << pin);
8726
8727
8728	snd_hda_codec_write(codec, codec->afg, 0,
8729			    AC_VERB_SET_GPIO_MASK, gpiomask);
8730	snd_hda_codec_write(codec, codec->afg, 0,
8731			    AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8732
8733	msleep(1);
8734
8735	snd_hda_codec_write(codec, codec->afg, 0,
8736			    AC_VERB_SET_GPIO_DATA, gpiostate);
8737}
8738
8739/* set up GPIO at initialization */
8740static void alc885_macpro_init_hook(struct hda_codec *codec)
8741{
8742	alc882_gpio_mute(codec, 0, 0);
8743	alc882_gpio_mute(codec, 1, 0);
8744}
8745
8746/* set up GPIO and update auto-muting at initialization */
8747static void alc885_imac24_init_hook(struct hda_codec *codec)
8748{
8749	alc885_macpro_init_hook(codec);
8750	alc_automute_amp(codec);
8751}
8752
8753/*
8754 * generic initialization of ADC, input mixers and output mixers
8755 */
8756static struct hda_verb alc883_auto_init_verbs[] = {
8757	/*
8758	 * Unmute ADC0-2 and set the default input to mic-in
8759	 */
8760	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8761	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8762	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8763	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8764
8765	/*
8766	 * Set up output mixers (0x0c - 0x0f)
8767	 */
8768	/* set vol=0 to output mixers */
8769	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8770	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8771	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8772	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8773	/* set up input amps for analog loopback */
8774	/* Amp Indices: DAC = 0, mixer = 1 */
8775	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8776	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8777	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8778	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8779	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8780	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8781	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8782	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8783	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8784	{0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8785
8786	/* FIXME: use matrix-type input source selection */
8787	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8788	/* Input mixer2 */
8789	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8790	/* Input mixer3 */
8791	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8792	{ }
8793};
8794
8795/* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8796static struct hda_verb alc889A_mb31_ch2_init[] = {
8797	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8798	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8799	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8800	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8801	{ } /* end */
8802};
8803
8804/* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8805static struct hda_verb alc889A_mb31_ch4_init[] = {
8806	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8807	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8808	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8809	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8810	{ } /* end */
8811};
8812
8813/* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8814static struct hda_verb alc889A_mb31_ch5_init[] = {
8815	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8816	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8817	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8818	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8819	{ } /* end */
8820};
8821
8822/* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8823static struct hda_verb alc889A_mb31_ch6_init[] = {
8824	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8825	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8826	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8827	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8828	{ } /* end */
8829};
8830
8831static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8832	{ 2, alc889A_mb31_ch2_init },
8833	{ 4, alc889A_mb31_ch4_init },
8834	{ 5, alc889A_mb31_ch5_init },
8835	{ 6, alc889A_mb31_ch6_init },
8836};
8837
8838static struct hda_verb alc883_medion_eapd_verbs[] = {
8839        /* eanable EAPD on medion laptop */
8840	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8841	{0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8842	{ }
8843};
8844
8845#define alc883_base_mixer	alc882_base_mixer
8846
8847static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8848	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8849	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8850	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8851	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8852	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8853	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8854	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8855	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8856	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8857	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8858	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8859	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8860	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8861	{ } /* end */
8862};
8863
8864static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8865	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8866	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8867	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8868	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8869	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8870	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8871	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8872	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8873	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8874	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8875	{ } /* end */
8876};
8877
8878static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8879	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8880	HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8881	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8882	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8883	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8884	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8885	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8886	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8887	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
8888	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8889	{ } /* end */
8890};
8891
8892static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8893	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8894	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8895	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8896	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8897	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8898	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8899	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8900	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8901	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8902	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8903	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8904	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8905	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8906	{ } /* end */
8907};
8908
8909static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8910	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8911	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8912	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8913	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8914	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8915	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8916	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8917	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8918	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8919	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8920	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8921	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8922	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8923	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8924	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8925	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8926	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8927	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8928	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8929	{ } /* end */
8930};
8931
8932static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8933	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8934	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8935	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8936	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8937	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8938			      HDA_OUTPUT),
8939	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8940	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8941	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8942	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8943	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8944	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8945	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8946	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8947	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8948	HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
8949	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8950	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8951	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
8952	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8953	{ } /* end */
8954};
8955
8956static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8957	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8958	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8959	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8960	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8961	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8962			      HDA_OUTPUT),
8963	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8964	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8965	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8966	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8967	HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8968	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8969	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8970	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8971	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8972	HDA_CODEC_VOLUME("Mic Boost Volume", 0x1b, 0, HDA_INPUT),
8973	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8974	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8975	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x18, 0, HDA_INPUT),
8976	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8977	{ } /* end */
8978};
8979
8980static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8981	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8982	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8983	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8984	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8985	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8986	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8987	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8988	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8989	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8990	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8991	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, 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	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8995	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
8996	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8997	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8998	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
8999	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9000	{ } /* end */
9001};
9002
9003static struct snd_kcontrol_new alc883_targa_mixer[] = {
9004	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9005	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9006	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9007	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9008	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9009	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
9010	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
9011	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9012	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
9013	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
9014	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9015	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9016	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9017	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9018	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9019	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9020	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9021	{ } /* end */
9022};
9023
9024static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
9025	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9026	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9027	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9028	HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9029	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9030	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9031	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9032	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9033	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9034	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9035	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9036	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9037	{ } /* end */
9038};
9039
9040static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
9041	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9042	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9043	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9044	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
9045	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9046	{ } /* end */
9047};
9048
9049static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
9050	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9051	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9052	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9053	HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
9054	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9055	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9056	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9057	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9058	{ } /* end */
9059};
9060
9061static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
9062	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9063	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
9064	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9065	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9066	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9067	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9068	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9069	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9070	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9071	{ } /* end */
9072};
9073
9074static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
9075	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9076	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9077	HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9078	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
9079	HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
9080	HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
9081	{ } /* end */
9082};
9083
9084static struct hda_verb alc883_medion_wim2160_verbs[] = {
9085	/* Unmute front mixer */
9086	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9087	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9088
9089	/* Set speaker pin to front mixer */
9090	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9091
9092	/* Init headphone pin */
9093	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9094	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9095	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9096	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9097
9098	{ } /* end */
9099};
9100
9101/* toggle speaker-output according to the hp-jack state */
9102static void alc883_medion_wim2160_setup(struct hda_codec *codec)
9103{
9104	struct alc_spec *spec = codec->spec;
9105
9106	spec->autocfg.hp_pins[0] = 0x1a;
9107	spec->autocfg.speaker_pins[0] = 0x15;
9108}
9109
9110static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
9111	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9112	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9113	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9114	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9115	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9116	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9117	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9118	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9119	{ } /* end */
9120};
9121
9122static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
9123	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9124	HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9125	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9126	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9127	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9128	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9129	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9130	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9131	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9132	{ } /* end */
9133};
9134
9135static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
9136	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9137	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9138	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9139	HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
9140	HDA_CODEC_VOLUME_MONO("Center Playback Volume",
9141						0x0d, 1, 0x0, HDA_OUTPUT),
9142	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
9143	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
9144	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
9145	HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
9146	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
9147	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9148	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9149	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9150	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9151	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9152	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9153	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9154	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9155	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
9156	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9157	{ } /* end */
9158};
9159
9160static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
9161	/* Output mixers */
9162	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
9163	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
9164	HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
9165	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
9166	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
9167		HDA_OUTPUT),
9168	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
9169	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
9170	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
9171	/* Output switches */
9172	HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
9173	HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
9174	HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
9175	/* Boost mixers */
9176	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x00, HDA_INPUT),
9177	HDA_CODEC_VOLUME("Line Boost Volume", 0x1a, 0x00, HDA_INPUT),
9178	/* Input mixers */
9179	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
9180	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
9181	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9182	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9183	{ } /* end */
9184};
9185
9186static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
9187	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9188	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9189	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9190	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
9191	HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
9192	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
9193	{ } /* end */
9194};
9195
9196static struct hda_bind_ctls alc883_bind_cap_vol = {
9197	.ops = &snd_hda_bind_vol,
9198	.values = {
9199		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9200		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9201		0
9202	},
9203};
9204
9205static struct hda_bind_ctls alc883_bind_cap_switch = {
9206	.ops = &snd_hda_bind_sw,
9207	.values = {
9208		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
9209		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
9210		0
9211	},
9212};
9213
9214static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
9215	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9216	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
9217	HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9218	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9219	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9220	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9221	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
9222	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9223	{ } /* end */
9224};
9225
9226static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
9227	HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
9228	HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
9229	{
9230		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9231		/* .name = "Capture Source", */
9232		.name = "Input Source",
9233		.count = 1,
9234		.info = alc_mux_enum_info,
9235		.get = alc_mux_enum_get,
9236		.put = alc_mux_enum_put,
9237	},
9238	{ } /* end */
9239};
9240
9241static struct snd_kcontrol_new alc883_chmode_mixer[] = {
9242	{
9243		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
9244		.name = "Channel Mode",
9245		.info = alc_ch_mode_info,
9246		.get = alc_ch_mode_get,
9247		.put = alc_ch_mode_put,
9248	},
9249	{ } /* end */
9250};
9251
9252/* toggle speaker-output according to the hp-jack state */
9253static void alc883_mitac_setup(struct hda_codec *codec)
9254{
9255	struct alc_spec *spec = codec->spec;
9256
9257	spec->autocfg.hp_pins[0] = 0x15;
9258	spec->autocfg.speaker_pins[0] = 0x14;
9259	spec->autocfg.speaker_pins[1] = 0x17;
9260}
9261
9262static struct hda_verb alc883_mitac_verbs[] = {
9263	/* HP */
9264	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9265	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9266	/* Subwoofer */
9267	{0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9268	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9269
9270	/* enable unsolicited event */
9271	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9272	/* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
9273
9274	{ } /* end */
9275};
9276
9277static struct hda_verb alc883_clevo_m540r_verbs[] = {
9278	/* HP */
9279	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9280	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9281	/* Int speaker */
9282	/*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9283
9284	/* enable unsolicited event */
9285	/*
9286	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9287	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9288	*/
9289
9290	{ } /* end */
9291};
9292
9293static struct hda_verb alc883_clevo_m720_verbs[] = {
9294	/* HP */
9295	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9296	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9297	/* Int speaker */
9298	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9299	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9300
9301	/* enable unsolicited event */
9302	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9303	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9304
9305	{ } /* end */
9306};
9307
9308static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9309	/* HP */
9310	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9311	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9312	/* Subwoofer */
9313	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9314	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9315
9316	/* enable unsolicited event */
9317	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9318
9319	{ } /* end */
9320};
9321
9322static struct hda_verb alc883_targa_verbs[] = {
9323	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9324	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9325
9326	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9327	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9328
9329/* Connect Line-Out side jack (SPDIF) to Side */
9330	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9331	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9332	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9333/* Connect Mic jack to CLFE */
9334	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9335	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9336	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9337/* Connect Line-in jack to Surround */
9338	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9339	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9340	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9341/* Connect HP out jack to Front */
9342	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9343	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9344	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9345
9346	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9347
9348	{ } /* end */
9349};
9350
9351static struct hda_verb alc883_lenovo_101e_verbs[] = {
9352	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9353	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9354        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9355	{ } /* end */
9356};
9357
9358static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9359        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9360	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9361        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9362        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9363	{ } /* end */
9364};
9365
9366static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9367	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9368	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9369	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9370	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9371	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9372	{ } /* end */
9373};
9374
9375static struct hda_verb alc883_haier_w66_verbs[] = {
9376	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9377	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9378
9379	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9380
9381	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9382	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9383	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9384	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9385	{ } /* end */
9386};
9387
9388static struct hda_verb alc888_lenovo_sky_verbs[] = {
9389	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9390	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9391	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9392	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9393	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9394	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9395	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9396	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9397	{ } /* end */
9398};
9399
9400static struct hda_verb alc888_6st_dell_verbs[] = {
9401	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9402	{ }
9403};
9404
9405static struct hda_verb alc883_vaiott_verbs[] = {
9406	/* HP */
9407	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9408	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9409
9410	/* enable unsolicited event */
9411	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9412
9413	{ } /* end */
9414};
9415
9416static void alc888_3st_hp_setup(struct hda_codec *codec)
9417{
9418	struct alc_spec *spec = codec->spec;
9419
9420	spec->autocfg.hp_pins[0] = 0x1b;
9421	spec->autocfg.speaker_pins[0] = 0x14;
9422	spec->autocfg.speaker_pins[1] = 0x16;
9423	spec->autocfg.speaker_pins[2] = 0x18;
9424}
9425
9426static struct hda_verb alc888_3st_hp_verbs[] = {
9427	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Front: output 0 (0x0c) */
9428	{0x16, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Rear : output 1 (0x0d) */
9429	{0x18, AC_VERB_SET_CONNECT_SEL, 0x02},	/* CLFE : output 2 (0x0e) */
9430	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9431	{ } /* end */
9432};
9433
9434/*
9435 * 2ch mode
9436 */
9437static struct hda_verb alc888_3st_hp_2ch_init[] = {
9438	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9439	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9440	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9441	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9442	{ } /* end */
9443};
9444
9445/*
9446 * 4ch mode
9447 */
9448static struct hda_verb alc888_3st_hp_4ch_init[] = {
9449	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9450	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9451	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9452	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9453	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9454	{ } /* end */
9455};
9456
9457/*
9458 * 6ch mode
9459 */
9460static struct hda_verb alc888_3st_hp_6ch_init[] = {
9461	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9462	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9463	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9464	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9465	{ 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9466	{ 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9467	{ } /* end */
9468};
9469
9470static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9471	{ 2, alc888_3st_hp_2ch_init },
9472	{ 4, alc888_3st_hp_4ch_init },
9473	{ 6, alc888_3st_hp_6ch_init },
9474};
9475
9476/* toggle front-jack and RCA according to the hp-jack state */
9477static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9478{
9479 	unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9480
9481	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9482				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9483	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9484				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9485}
9486
9487/* toggle RCA according to the front-jack state */
9488static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9489{
9490 	unsigned int present = snd_hda_jack_detect(codec, 0x14);
9491
9492	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9493				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9494}
9495
9496static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9497					     unsigned int res)
9498{
9499	if ((res >> 26) == ALC880_HP_EVENT)
9500		alc888_lenovo_ms7195_front_automute(codec);
9501	if ((res >> 26) == ALC880_FRONT_EVENT)
9502		alc888_lenovo_ms7195_rca_automute(codec);
9503}
9504
9505/* toggle speaker-output according to the hp-jack state */
9506static void alc883_lenovo_nb0763_setup(struct hda_codec *codec)
9507{
9508	struct alc_spec *spec = codec->spec;
9509
9510	spec->autocfg.hp_pins[0] = 0x14;
9511	spec->autocfg.speaker_pins[0] = 0x15;
9512}
9513
9514/* toggle speaker-output according to the hp-jack state */
9515#define alc883_targa_init_hook		alc882_targa_init_hook
9516#define alc883_targa_unsol_event	alc882_targa_unsol_event
9517
9518static void alc883_clevo_m720_setup(struct hda_codec *codec)
9519{
9520	struct alc_spec *spec = codec->spec;
9521
9522	spec->autocfg.hp_pins[0] = 0x15;
9523	spec->autocfg.speaker_pins[0] = 0x14;
9524}
9525
9526static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9527{
9528	alc_automute_amp(codec);
9529	alc88x_simple_mic_automute(codec);
9530}
9531
9532static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9533					   unsigned int res)
9534{
9535	switch (res >> 26) {
9536	case ALC880_MIC_EVENT:
9537		alc88x_simple_mic_automute(codec);
9538		break;
9539	default:
9540		alc_automute_amp_unsol_event(codec, res);
9541		break;
9542	}
9543}
9544
9545/* toggle speaker-output according to the hp-jack state */
9546static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9547{
9548	struct alc_spec *spec = codec->spec;
9549
9550	spec->autocfg.hp_pins[0] = 0x14;
9551	spec->autocfg.speaker_pins[0] = 0x15;
9552}
9553
9554static void alc883_haier_w66_setup(struct hda_codec *codec)
9555{
9556	struct alc_spec *spec = codec->spec;
9557
9558	spec->autocfg.hp_pins[0] = 0x1b;
9559	spec->autocfg.speaker_pins[0] = 0x14;
9560}
9561
9562static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9563{
9564	int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9565
9566	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9567				 HDA_AMP_MUTE, bits);
9568}
9569
9570static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9571{
9572	int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9573
9574	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9575				 HDA_AMP_MUTE, bits);
9576	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9577				 HDA_AMP_MUTE, bits);
9578}
9579
9580static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9581					   unsigned int res)
9582{
9583	if ((res >> 26) == ALC880_HP_EVENT)
9584		alc883_lenovo_101e_all_automute(codec);
9585	if ((res >> 26) == ALC880_FRONT_EVENT)
9586		alc883_lenovo_101e_ispeaker_automute(codec);
9587}
9588
9589/* toggle speaker-output according to the hp-jack state */
9590static void alc883_acer_aspire_setup(struct hda_codec *codec)
9591{
9592	struct alc_spec *spec = codec->spec;
9593
9594	spec->autocfg.hp_pins[0] = 0x14;
9595	spec->autocfg.speaker_pins[0] = 0x15;
9596	spec->autocfg.speaker_pins[1] = 0x16;
9597}
9598
9599static struct hda_verb alc883_acer_eapd_verbs[] = {
9600	/* HP Pin: output 0 (0x0c) */
9601	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9602	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9603	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9604	/* Front Pin: output 0 (0x0c) */
9605	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9606	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9607	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9608	{0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9609        /* eanable EAPD on medion laptop */
9610	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9611	{0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9612	/* enable unsolicited event */
9613	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9614	{ }
9615};
9616
9617static void alc888_6st_dell_setup(struct hda_codec *codec)
9618{
9619	struct alc_spec *spec = codec->spec;
9620
9621	spec->autocfg.hp_pins[0] = 0x1b;
9622	spec->autocfg.speaker_pins[0] = 0x14;
9623	spec->autocfg.speaker_pins[1] = 0x15;
9624	spec->autocfg.speaker_pins[2] = 0x16;
9625	spec->autocfg.speaker_pins[3] = 0x17;
9626}
9627
9628static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9629{
9630	struct alc_spec *spec = codec->spec;
9631
9632	spec->autocfg.hp_pins[0] = 0x1b;
9633	spec->autocfg.speaker_pins[0] = 0x14;
9634	spec->autocfg.speaker_pins[1] = 0x15;
9635	spec->autocfg.speaker_pins[2] = 0x16;
9636	spec->autocfg.speaker_pins[3] = 0x17;
9637	spec->autocfg.speaker_pins[4] = 0x1a;
9638}
9639
9640static void alc883_vaiott_setup(struct hda_codec *codec)
9641{
9642	struct alc_spec *spec = codec->spec;
9643
9644	spec->autocfg.hp_pins[0] = 0x15;
9645	spec->autocfg.speaker_pins[0] = 0x14;
9646	spec->autocfg.speaker_pins[1] = 0x17;
9647}
9648
9649static struct hda_verb alc888_asus_m90v_verbs[] = {
9650	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9651	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9652	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9653	/* enable unsolicited event */
9654	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9655	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9656	{ } /* end */
9657};
9658
9659static void alc883_mode2_setup(struct hda_codec *codec)
9660{
9661	struct alc_spec *spec = codec->spec;
9662
9663	spec->autocfg.hp_pins[0] = 0x1b;
9664	spec->autocfg.speaker_pins[0] = 0x14;
9665	spec->autocfg.speaker_pins[1] = 0x15;
9666	spec->autocfg.speaker_pins[2] = 0x16;
9667	spec->ext_mic.pin = 0x18;
9668	spec->int_mic.pin = 0x19;
9669	spec->ext_mic.mux_idx = 0;
9670	spec->int_mic.mux_idx = 1;
9671	spec->auto_mic = 1;
9672}
9673
9674static struct hda_verb alc888_asus_eee1601_verbs[] = {
9675	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9676	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9677	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9678	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9679	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9680	{0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9681	{0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9682	/* enable unsolicited event */
9683	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9684	{ } /* end */
9685};
9686
9687static void alc883_eee1601_inithook(struct hda_codec *codec)
9688{
9689	struct alc_spec *spec = codec->spec;
9690
9691	spec->autocfg.hp_pins[0] = 0x14;
9692	spec->autocfg.speaker_pins[0] = 0x1b;
9693	alc_automute_pin(codec);
9694}
9695
9696static struct hda_verb alc889A_mb31_verbs[] = {
9697	/* Init rear pin (used as headphone output) */
9698	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9699	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9700	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9701	/* Init line pin (used as output in 4ch and 6ch mode) */
9702	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9703	/* Init line 2 pin (used as headphone out by default) */
9704	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9705	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9706	{ } /* end */
9707};
9708
9709/* Mute speakers according to the headphone jack state */
9710static void alc889A_mb31_automute(struct hda_codec *codec)
9711{
9712	unsigned int present;
9713
9714	/* Mute only in 2ch or 4ch mode */
9715	if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9716	    == 0x00) {
9717		present = snd_hda_jack_detect(codec, 0x15);
9718		snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9719			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9720		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9721			HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9722	}
9723}
9724
9725static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9726{
9727	if ((res >> 26) == ALC880_HP_EVENT)
9728		alc889A_mb31_automute(codec);
9729}
9730
9731
9732#ifdef CONFIG_SND_HDA_POWER_SAVE
9733#define alc882_loopbacks	alc880_loopbacks
9734#endif
9735
9736/* pcm configuration: identical with ALC880 */
9737#define alc882_pcm_analog_playback	alc880_pcm_analog_playback
9738#define alc882_pcm_analog_capture	alc880_pcm_analog_capture
9739#define alc882_pcm_digital_playback	alc880_pcm_digital_playback
9740#define alc882_pcm_digital_capture	alc880_pcm_digital_capture
9741
9742static hda_nid_t alc883_slave_dig_outs[] = {
9743	ALC1200_DIGOUT_NID, 0,
9744};
9745
9746static hda_nid_t alc1200_slave_dig_outs[] = {
9747	ALC883_DIGOUT_NID, 0,
9748};
9749
9750/*
9751 * configuration and preset
9752 */
9753static const char * const alc882_models[ALC882_MODEL_LAST] = {
9754	[ALC882_3ST_DIG]	= "3stack-dig",
9755	[ALC882_6ST_DIG]	= "6stack-dig",
9756	[ALC882_ARIMA]		= "arima",
9757	[ALC882_W2JC]		= "w2jc",
9758	[ALC882_TARGA]		= "targa",
9759	[ALC882_ASUS_A7J]	= "asus-a7j",
9760	[ALC882_ASUS_A7M]	= "asus-a7m",
9761	[ALC885_MACPRO]		= "macpro",
9762	[ALC885_MB5]		= "mb5",
9763	[ALC885_MACMINI3]	= "macmini3",
9764	[ALC885_MBA21]		= "mba21",
9765	[ALC885_MBP3]		= "mbp3",
9766	[ALC885_IMAC24]		= "imac24",
9767	[ALC885_IMAC91]		= "imac91",
9768	[ALC883_3ST_2ch_DIG]	= "3stack-2ch-dig",
9769	[ALC883_3ST_6ch_DIG]	= "3stack-6ch-dig",
9770	[ALC883_3ST_6ch]	= "3stack-6ch",
9771	[ALC883_6ST_DIG]	= "alc883-6stack-dig",
9772	[ALC883_TARGA_DIG]	= "targa-dig",
9773	[ALC883_TARGA_2ch_DIG]	= "targa-2ch-dig",
9774	[ALC883_TARGA_8ch_DIG]	= "targa-8ch-dig",
9775	[ALC883_ACER]		= "acer",
9776	[ALC883_ACER_ASPIRE]	= "acer-aspire",
9777	[ALC888_ACER_ASPIRE_4930G]	= "acer-aspire-4930g",
9778	[ALC888_ACER_ASPIRE_6530G]	= "acer-aspire-6530g",
9779	[ALC888_ACER_ASPIRE_8930G]	= "acer-aspire-8930g",
9780	[ALC888_ACER_ASPIRE_7730G]	= "acer-aspire-7730g",
9781	[ALC883_MEDION]		= "medion",
9782	[ALC883_MEDION_WIM2160]	= "medion-wim2160",
9783	[ALC883_LAPTOP_EAPD]	= "laptop-eapd",
9784	[ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9785	[ALC883_LENOVO_NB0763]	= "lenovo-nb0763",
9786	[ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9787	[ALC888_LENOVO_SKY] = "lenovo-sky",
9788	[ALC883_HAIER_W66] 	= "haier-w66",
9789	[ALC888_3ST_HP]		= "3stack-hp",
9790	[ALC888_6ST_DELL]	= "6stack-dell",
9791	[ALC883_MITAC]		= "mitac",
9792	[ALC883_CLEVO_M540R]	= "clevo-m540r",
9793	[ALC883_CLEVO_M720]	= "clevo-m720",
9794	[ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9795	[ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9796	[ALC883_3ST_6ch_INTEL]	= "3stack-6ch-intel",
9797	[ALC889A_INTEL]		= "intel-alc889a",
9798	[ALC889_INTEL]		= "intel-x58",
9799	[ALC1200_ASUS_P5Q]	= "asus-p5q",
9800	[ALC889A_MB31]		= "mb31",
9801	[ALC883_SONY_VAIO_TT]	= "sony-vaio-tt",
9802	[ALC882_AUTO]		= "auto",
9803};
9804
9805static struct snd_pci_quirk alc882_cfg_tbl[] = {
9806	SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9807
9808	SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9809	SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9810	SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9811	SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9812	SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9813	SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9814	SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9815		ALC888_ACER_ASPIRE_4930G),
9816	SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9817		ALC888_ACER_ASPIRE_4930G),
9818	SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9819		ALC888_ACER_ASPIRE_8930G),
9820	SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9821		ALC888_ACER_ASPIRE_8930G),
9822	SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9823	SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9824	SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9825		ALC888_ACER_ASPIRE_6530G),
9826	SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9827		ALC888_ACER_ASPIRE_6530G),
9828	SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9829		ALC888_ACER_ASPIRE_7730G),
9830	/* default Acer -- disabled as it causes more problems.
9831	 *    model=auto should work fine now
9832	 */
9833	/* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9834
9835	SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9836
9837	SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9838	SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9839	SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9840	SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9841	SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9842	SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9843
9844	SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9845	SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9846	SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9847	SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9848	SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9849	SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9850	SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9851	SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9852	SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9853	SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9854	SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9855
9856	SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9857	SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9858	SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9859	SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9860	SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9861	SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9862	SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9863	SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9864	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9865
9866	SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9867	SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9868	SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9869	SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9870	SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9871	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9872	SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9873	SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9874	SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9875	SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9876	SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9877	SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9878	SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9879	SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9880	SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9881	SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9882	SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9883	SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9884	SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9885	SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9886	SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9887	SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9888	SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9889	SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9890	SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9891	SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9892	SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9893	SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9894	SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9895	SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9896	SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9897
9898	SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9899	SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9900	SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9901	SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9902	SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9903	SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9904	SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9905	/* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9906	SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9907	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9908		      ALC883_FUJITSU_PI2515),
9909	SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9910		ALC888_FUJITSU_XA3530),
9911	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9912	SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9913	SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9914	SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9915	SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9916	SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9917	SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9918	SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9919
9920	SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9921	SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9922	SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9923	SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9924	SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9925	SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9926	SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9927
9928	{}
9929};
9930
9931/* codec SSID table for Intel Mac */
9932static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9933	SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9934	SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9935	SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9936	SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9937	SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9938	SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9939	SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9940	SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9941	SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9942	SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9943	SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9944	SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9945	SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9946	SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9947	SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9948	SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9949	SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9950	/* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9951	 * so apparently no perfect solution yet
9952	 */
9953	SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9954	SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9955	SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9956	{} /* terminator */
9957};
9958
9959static struct alc_config_preset alc882_presets[] = {
9960	[ALC882_3ST_DIG] = {
9961		.mixers = { alc882_base_mixer },
9962		.init_verbs = { alc882_base_init_verbs,
9963				alc882_adc1_init_verbs },
9964		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9965		.dac_nids = alc882_dac_nids,
9966		.dig_out_nid = ALC882_DIGOUT_NID,
9967		.dig_in_nid = ALC882_DIGIN_NID,
9968		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9969		.channel_mode = alc882_ch_modes,
9970		.need_dac_fix = 1,
9971		.input_mux = &alc882_capture_source,
9972	},
9973	[ALC882_6ST_DIG] = {
9974		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9975		.init_verbs = { alc882_base_init_verbs,
9976				alc882_adc1_init_verbs },
9977		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9978		.dac_nids = alc882_dac_nids,
9979		.dig_out_nid = ALC882_DIGOUT_NID,
9980		.dig_in_nid = ALC882_DIGIN_NID,
9981		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9982		.channel_mode = alc882_sixstack_modes,
9983		.input_mux = &alc882_capture_source,
9984	},
9985	[ALC882_ARIMA] = {
9986		.mixers = { alc882_base_mixer, alc882_chmode_mixer },
9987		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9988				alc882_eapd_verbs },
9989		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
9990		.dac_nids = alc882_dac_nids,
9991		.num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9992		.channel_mode = alc882_sixstack_modes,
9993		.input_mux = &alc882_capture_source,
9994	},
9995	[ALC882_W2JC] = {
9996		.mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9997		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9998				alc882_eapd_verbs, alc880_gpio1_init_verbs },
9999		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10000		.dac_nids = alc882_dac_nids,
10001		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10002		.channel_mode = alc880_threestack_modes,
10003		.need_dac_fix = 1,
10004		.input_mux = &alc882_capture_source,
10005		.dig_out_nid = ALC882_DIGOUT_NID,
10006	},
10007	   [ALC885_MBA21] = {
10008			.mixers = { alc885_mba21_mixer },
10009			.init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
10010			.num_dacs = 2,
10011			.dac_nids = alc882_dac_nids,
10012			.channel_mode = alc885_mba21_ch_modes,
10013			.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10014			.input_mux = &alc882_capture_source,
10015			.unsol_event = alc_automute_amp_unsol_event,
10016			.setup = alc885_mba21_setup,
10017			.init_hook = alc_automute_amp,
10018       },
10019	[ALC885_MBP3] = {
10020		.mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
10021		.init_verbs = { alc885_mbp3_init_verbs,
10022				alc880_gpio1_init_verbs },
10023		.num_dacs = 2,
10024		.dac_nids = alc882_dac_nids,
10025		.hp_nid = 0x04,
10026		.channel_mode = alc885_mbp_4ch_modes,
10027		.num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
10028		.input_mux = &alc882_capture_source,
10029		.dig_out_nid = ALC882_DIGOUT_NID,
10030		.dig_in_nid = ALC882_DIGIN_NID,
10031		.unsol_event = alc_automute_amp_unsol_event,
10032		.setup = alc885_mbp3_setup,
10033		.init_hook = alc_automute_amp,
10034	},
10035	[ALC885_MB5] = {
10036		.mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
10037		.init_verbs = { alc885_mb5_init_verbs,
10038				alc880_gpio1_init_verbs },
10039		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10040		.dac_nids = alc882_dac_nids,
10041		.channel_mode = alc885_mb5_6ch_modes,
10042		.num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
10043		.input_mux = &mb5_capture_source,
10044		.dig_out_nid = ALC882_DIGOUT_NID,
10045		.dig_in_nid = ALC882_DIGIN_NID,
10046		.unsol_event = alc_automute_amp_unsol_event,
10047		.setup = alc885_mb5_setup,
10048		.init_hook = alc_automute_amp,
10049	},
10050	[ALC885_MACMINI3] = {
10051		.mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
10052		.init_verbs = { alc885_macmini3_init_verbs,
10053				alc880_gpio1_init_verbs },
10054		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10055		.dac_nids = alc882_dac_nids,
10056		.channel_mode = alc885_macmini3_6ch_modes,
10057		.num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
10058		.input_mux = &macmini3_capture_source,
10059		.dig_out_nid = ALC882_DIGOUT_NID,
10060		.dig_in_nid = ALC882_DIGIN_NID,
10061		.unsol_event = alc_automute_amp_unsol_event,
10062		.setup = alc885_macmini3_setup,
10063		.init_hook = alc_automute_amp,
10064	},
10065	[ALC885_MACPRO] = {
10066		.mixers = { alc882_macpro_mixer },
10067		.init_verbs = { alc882_macpro_init_verbs },
10068		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10069		.dac_nids = alc882_dac_nids,
10070		.dig_out_nid = ALC882_DIGOUT_NID,
10071		.dig_in_nid = ALC882_DIGIN_NID,
10072		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10073		.channel_mode = alc882_ch_modes,
10074		.input_mux = &alc882_capture_source,
10075		.init_hook = alc885_macpro_init_hook,
10076	},
10077	[ALC885_IMAC24] = {
10078		.mixers = { alc885_imac24_mixer },
10079		.init_verbs = { alc885_imac24_init_verbs },
10080		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10081		.dac_nids = alc882_dac_nids,
10082		.dig_out_nid = ALC882_DIGOUT_NID,
10083		.dig_in_nid = ALC882_DIGIN_NID,
10084		.num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
10085		.channel_mode = alc882_ch_modes,
10086		.input_mux = &alc882_capture_source,
10087		.unsol_event = alc_automute_amp_unsol_event,
10088		.setup = alc885_imac24_setup,
10089		.init_hook = alc885_imac24_init_hook,
10090	},
10091	[ALC885_IMAC91] = {
10092		.mixers = {alc885_imac91_mixer},
10093		.init_verbs = { alc885_imac91_init_verbs,
10094				alc880_gpio1_init_verbs },
10095		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10096		.dac_nids = alc882_dac_nids,
10097		.channel_mode = alc885_mba21_ch_modes,
10098		.num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
10099		.input_mux = &alc889A_imac91_capture_source,
10100		.dig_out_nid = ALC882_DIGOUT_NID,
10101		.dig_in_nid = ALC882_DIGIN_NID,
10102		.unsol_event = alc_automute_amp_unsol_event,
10103		.setup = alc885_imac91_setup,
10104		.init_hook = alc_automute_amp,
10105	},
10106	[ALC882_TARGA] = {
10107		.mixers = { alc882_targa_mixer, alc882_chmode_mixer },
10108		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10109				alc880_gpio3_init_verbs, alc882_targa_verbs},
10110		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10111		.dac_nids = alc882_dac_nids,
10112		.dig_out_nid = ALC882_DIGOUT_NID,
10113		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10114		.adc_nids = alc882_adc_nids,
10115		.capsrc_nids = alc882_capsrc_nids,
10116		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10117		.channel_mode = alc882_3ST_6ch_modes,
10118		.need_dac_fix = 1,
10119		.input_mux = &alc882_capture_source,
10120		.unsol_event = alc882_targa_unsol_event,
10121		.setup = alc882_targa_setup,
10122		.init_hook = alc882_targa_automute,
10123	},
10124	[ALC882_ASUS_A7J] = {
10125		.mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
10126		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10127				alc882_asus_a7j_verbs},
10128		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10129		.dac_nids = alc882_dac_nids,
10130		.dig_out_nid = ALC882_DIGOUT_NID,
10131		.num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
10132		.adc_nids = alc882_adc_nids,
10133		.capsrc_nids = alc882_capsrc_nids,
10134		.num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
10135		.channel_mode = alc882_3ST_6ch_modes,
10136		.need_dac_fix = 1,
10137		.input_mux = &alc882_capture_source,
10138	},
10139	[ALC882_ASUS_A7M] = {
10140		.mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
10141		.init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
10142				alc882_eapd_verbs, alc880_gpio1_init_verbs,
10143				alc882_asus_a7m_verbs },
10144		.num_dacs = ARRAY_SIZE(alc882_dac_nids),
10145		.dac_nids = alc882_dac_nids,
10146		.dig_out_nid = ALC882_DIGOUT_NID,
10147		.num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
10148		.channel_mode = alc880_threestack_modes,
10149		.need_dac_fix = 1,
10150		.input_mux = &alc882_capture_source,
10151	},
10152	[ALC883_3ST_2ch_DIG] = {
10153		.mixers = { alc883_3ST_2ch_mixer },
10154		.init_verbs = { alc883_init_verbs },
10155		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10156		.dac_nids = alc883_dac_nids,
10157		.dig_out_nid = ALC883_DIGOUT_NID,
10158		.dig_in_nid = ALC883_DIGIN_NID,
10159		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10160		.channel_mode = alc883_3ST_2ch_modes,
10161		.input_mux = &alc883_capture_source,
10162	},
10163	[ALC883_3ST_6ch_DIG] = {
10164		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10165		.init_verbs = { alc883_init_verbs },
10166		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10167		.dac_nids = alc883_dac_nids,
10168		.dig_out_nid = ALC883_DIGOUT_NID,
10169		.dig_in_nid = ALC883_DIGIN_NID,
10170		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10171		.channel_mode = alc883_3ST_6ch_modes,
10172		.need_dac_fix = 1,
10173		.input_mux = &alc883_capture_source,
10174	},
10175	[ALC883_3ST_6ch] = {
10176		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10177		.init_verbs = { alc883_init_verbs },
10178		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10179		.dac_nids = alc883_dac_nids,
10180		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10181		.channel_mode = alc883_3ST_6ch_modes,
10182		.need_dac_fix = 1,
10183		.input_mux = &alc883_capture_source,
10184	},
10185	[ALC883_3ST_6ch_INTEL] = {
10186		.mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
10187		.init_verbs = { alc883_init_verbs },
10188		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10189		.dac_nids = alc883_dac_nids,
10190		.dig_out_nid = ALC883_DIGOUT_NID,
10191		.dig_in_nid = ALC883_DIGIN_NID,
10192		.slave_dig_outs = alc883_slave_dig_outs,
10193		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
10194		.channel_mode = alc883_3ST_6ch_intel_modes,
10195		.need_dac_fix = 1,
10196		.input_mux = &alc883_3stack_6ch_intel,
10197	},
10198	[ALC889A_INTEL] = {
10199		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10200		.init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
10201				alc_hp15_unsol_verbs },
10202		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10203		.dac_nids = alc883_dac_nids,
10204		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10205		.adc_nids = alc889_adc_nids,
10206		.dig_out_nid = ALC883_DIGOUT_NID,
10207		.dig_in_nid = ALC883_DIGIN_NID,
10208		.slave_dig_outs = alc883_slave_dig_outs,
10209		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10210		.channel_mode = alc889_8ch_intel_modes,
10211		.capsrc_nids = alc889_capsrc_nids,
10212		.input_mux = &alc889_capture_source,
10213		.setup = alc889_automute_setup,
10214		.init_hook = alc_automute_amp,
10215		.unsol_event = alc_automute_amp_unsol_event,
10216		.need_dac_fix = 1,
10217	},
10218	[ALC889_INTEL] = {
10219		.mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
10220		.init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
10221				alc889_eapd_verbs, alc_hp15_unsol_verbs},
10222		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10223		.dac_nids = alc883_dac_nids,
10224		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10225		.adc_nids = alc889_adc_nids,
10226		.dig_out_nid = ALC883_DIGOUT_NID,
10227		.dig_in_nid = ALC883_DIGIN_NID,
10228		.slave_dig_outs = alc883_slave_dig_outs,
10229		.num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
10230		.channel_mode = alc889_8ch_intel_modes,
10231		.capsrc_nids = alc889_capsrc_nids,
10232		.input_mux = &alc889_capture_source,
10233		.setup = alc889_automute_setup,
10234		.init_hook = alc889_intel_init_hook,
10235		.unsol_event = alc_automute_amp_unsol_event,
10236		.need_dac_fix = 1,
10237	},
10238	[ALC883_6ST_DIG] = {
10239		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10240		.init_verbs = { alc883_init_verbs },
10241		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10242		.dac_nids = alc883_dac_nids,
10243		.dig_out_nid = ALC883_DIGOUT_NID,
10244		.dig_in_nid = ALC883_DIGIN_NID,
10245		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10246		.channel_mode = alc883_sixstack_modes,
10247		.input_mux = &alc883_capture_source,
10248	},
10249	[ALC883_TARGA_DIG] = {
10250		.mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10251		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10252				alc883_targa_verbs},
10253		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10254		.dac_nids = alc883_dac_nids,
10255		.dig_out_nid = ALC883_DIGOUT_NID,
10256		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10257		.channel_mode = alc883_3ST_6ch_modes,
10258		.need_dac_fix = 1,
10259		.input_mux = &alc883_capture_source,
10260		.unsol_event = alc883_targa_unsol_event,
10261		.setup = alc882_targa_setup,
10262		.init_hook = alc882_targa_automute,
10263	},
10264	[ALC883_TARGA_2ch_DIG] = {
10265		.mixers = { alc883_targa_2ch_mixer},
10266		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10267				alc883_targa_verbs},
10268		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10269		.dac_nids = alc883_dac_nids,
10270		.adc_nids = alc883_adc_nids_alt,
10271		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10272		.capsrc_nids = alc883_capsrc_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 = alc883_targa_unsol_event,
10278		.setup = alc882_targa_setup,
10279		.init_hook = alc882_targa_automute,
10280	},
10281	[ALC883_TARGA_8ch_DIG] = {
10282		.mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10283			    alc883_chmode_mixer },
10284		.init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10285				alc883_targa_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		.dig_in_nid = ALC883_DIGIN_NID,
10293		.num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10294		.channel_mode = alc883_4ST_8ch_modes,
10295		.need_dac_fix = 1,
10296		.input_mux = &alc883_capture_source,
10297		.unsol_event = alc883_targa_unsol_event,
10298		.setup = alc882_targa_setup,
10299		.init_hook = alc882_targa_automute,
10300	},
10301	[ALC883_ACER] = {
10302		.mixers = { alc883_base_mixer },
10303		/* On TravelMate laptops, GPIO 0 enables the internal speaker
10304		 * and the headphone jack.  Turn this on and rely on the
10305		 * standard mute methods whenever the user wants to turn
10306		 * these outputs off.
10307		 */
10308		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10309		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10310		.dac_nids = alc883_dac_nids,
10311		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10312		.channel_mode = alc883_3ST_2ch_modes,
10313		.input_mux = &alc883_capture_source,
10314	},
10315	[ALC883_ACER_ASPIRE] = {
10316		.mixers = { alc883_acer_aspire_mixer },
10317		.init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10318		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10319		.dac_nids = alc883_dac_nids,
10320		.dig_out_nid = ALC883_DIGOUT_NID,
10321		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10322		.channel_mode = alc883_3ST_2ch_modes,
10323		.input_mux = &alc883_capture_source,
10324		.unsol_event = alc_automute_amp_unsol_event,
10325		.setup = alc883_acer_aspire_setup,
10326		.init_hook = alc_automute_amp,
10327	},
10328	[ALC888_ACER_ASPIRE_4930G] = {
10329		.mixers = { alc888_acer_aspire_4930g_mixer,
10330				alc883_chmode_mixer },
10331		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10332				alc888_acer_aspire_4930g_verbs },
10333		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10334		.dac_nids = alc883_dac_nids,
10335		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10336		.adc_nids = alc883_adc_nids_rev,
10337		.capsrc_nids = alc883_capsrc_nids_rev,
10338		.dig_out_nid = ALC883_DIGOUT_NID,
10339		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10340		.channel_mode = alc883_3ST_6ch_modes,
10341		.need_dac_fix = 1,
10342		.const_channel_count = 6,
10343		.num_mux_defs =
10344			ARRAY_SIZE(alc888_2_capture_sources),
10345		.input_mux = alc888_2_capture_sources,
10346		.unsol_event = alc_automute_amp_unsol_event,
10347		.setup = alc888_acer_aspire_4930g_setup,
10348		.init_hook = alc_automute_amp,
10349	},
10350	[ALC888_ACER_ASPIRE_6530G] = {
10351		.mixers = { alc888_acer_aspire_6530_mixer },
10352		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10353				alc888_acer_aspire_6530g_verbs },
10354		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10355		.dac_nids = alc883_dac_nids,
10356		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10357		.adc_nids = alc883_adc_nids_rev,
10358		.capsrc_nids = alc883_capsrc_nids_rev,
10359		.dig_out_nid = ALC883_DIGOUT_NID,
10360		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10361		.channel_mode = alc883_3ST_2ch_modes,
10362		.num_mux_defs =
10363			ARRAY_SIZE(alc888_2_capture_sources),
10364		.input_mux = alc888_acer_aspire_6530_sources,
10365		.unsol_event = alc_automute_amp_unsol_event,
10366		.setup = alc888_acer_aspire_6530g_setup,
10367		.init_hook = alc_automute_amp,
10368	},
10369	[ALC888_ACER_ASPIRE_8930G] = {
10370		.mixers = { alc889_acer_aspire_8930g_mixer,
10371				alc883_chmode_mixer },
10372		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10373				alc889_acer_aspire_8930g_verbs,
10374				alc889_eapd_verbs},
10375		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10376		.dac_nids = alc883_dac_nids,
10377		.num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10378		.adc_nids = alc889_adc_nids,
10379		.capsrc_nids = alc889_capsrc_nids,
10380		.dig_out_nid = ALC883_DIGOUT_NID,
10381		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10382		.channel_mode = alc883_3ST_6ch_modes,
10383		.need_dac_fix = 1,
10384		.const_channel_count = 6,
10385		.num_mux_defs =
10386			ARRAY_SIZE(alc889_capture_sources),
10387		.input_mux = alc889_capture_sources,
10388		.unsol_event = alc_automute_amp_unsol_event,
10389		.setup = alc889_acer_aspire_8930g_setup,
10390		.init_hook = alc_automute_amp,
10391#ifdef CONFIG_SND_HDA_POWER_SAVE
10392		.power_hook = alc_power_eapd,
10393#endif
10394	},
10395	[ALC888_ACER_ASPIRE_7730G] = {
10396		.mixers = { alc883_3ST_6ch_mixer,
10397				alc883_chmode_mixer },
10398		.init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10399				alc888_acer_aspire_7730G_verbs },
10400		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10401		.dac_nids = alc883_dac_nids,
10402		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10403		.adc_nids = alc883_adc_nids_rev,
10404		.capsrc_nids = alc883_capsrc_nids_rev,
10405		.dig_out_nid = ALC883_DIGOUT_NID,
10406		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10407		.channel_mode = alc883_3ST_6ch_modes,
10408		.need_dac_fix = 1,
10409		.const_channel_count = 6,
10410		.input_mux = &alc883_capture_source,
10411		.unsol_event = alc_automute_amp_unsol_event,
10412		.setup = alc888_acer_aspire_7730g_setup,
10413		.init_hook = alc_automute_amp,
10414	},
10415	[ALC883_MEDION] = {
10416		.mixers = { alc883_fivestack_mixer,
10417			    alc883_chmode_mixer },
10418		.init_verbs = { alc883_init_verbs,
10419				alc883_medion_eapd_verbs },
10420		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10421		.dac_nids = alc883_dac_nids,
10422		.adc_nids = alc883_adc_nids_alt,
10423		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10424		.capsrc_nids = alc883_capsrc_nids,
10425		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10426		.channel_mode = alc883_sixstack_modes,
10427		.input_mux = &alc883_capture_source,
10428	},
10429	[ALC883_MEDION_WIM2160] = {
10430		.mixers = { alc883_medion_wim2160_mixer },
10431		.init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10432		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10433		.dac_nids = alc883_dac_nids,
10434		.dig_out_nid = ALC883_DIGOUT_NID,
10435		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10436		.adc_nids = alc883_adc_nids,
10437		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10438		.channel_mode = alc883_3ST_2ch_modes,
10439		.input_mux = &alc883_capture_source,
10440		.unsol_event = alc_automute_amp_unsol_event,
10441		.setup = alc883_medion_wim2160_setup,
10442		.init_hook = alc_automute_amp,
10443	},
10444	[ALC883_LAPTOP_EAPD] = {
10445		.mixers = { alc883_base_mixer },
10446		.init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10447		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10448		.dac_nids = alc883_dac_nids,
10449		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10450		.channel_mode = alc883_3ST_2ch_modes,
10451		.input_mux = &alc883_capture_source,
10452	},
10453	[ALC883_CLEVO_M540R] = {
10454		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10455		.init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10456		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10457		.dac_nids = alc883_dac_nids,
10458		.dig_out_nid = ALC883_DIGOUT_NID,
10459		.dig_in_nid = ALC883_DIGIN_NID,
10460		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10461		.channel_mode = alc883_3ST_6ch_clevo_modes,
10462		.need_dac_fix = 1,
10463		.input_mux = &alc883_capture_source,
10464		/* This machine has the hardware HP auto-muting, thus
10465		 * we need no software mute via unsol event
10466		 */
10467	},
10468	[ALC883_CLEVO_M720] = {
10469		.mixers = { alc883_clevo_m720_mixer },
10470		.init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10471		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10472		.dac_nids = alc883_dac_nids,
10473		.dig_out_nid = ALC883_DIGOUT_NID,
10474		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10475		.channel_mode = alc883_3ST_2ch_modes,
10476		.input_mux = &alc883_capture_source,
10477		.unsol_event = alc883_clevo_m720_unsol_event,
10478		.setup = alc883_clevo_m720_setup,
10479		.init_hook = alc883_clevo_m720_init_hook,
10480	},
10481	[ALC883_LENOVO_101E_2ch] = {
10482		.mixers = { alc883_lenovo_101e_2ch_mixer},
10483		.init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10484		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10485		.dac_nids = alc883_dac_nids,
10486		.adc_nids = alc883_adc_nids_alt,
10487		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10488		.capsrc_nids = alc883_capsrc_nids,
10489		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10490		.channel_mode = alc883_3ST_2ch_modes,
10491		.input_mux = &alc883_lenovo_101e_capture_source,
10492		.unsol_event = alc883_lenovo_101e_unsol_event,
10493		.init_hook = alc883_lenovo_101e_all_automute,
10494	},
10495	[ALC883_LENOVO_NB0763] = {
10496		.mixers = { alc883_lenovo_nb0763_mixer },
10497		.init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10498		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10499		.dac_nids = alc883_dac_nids,
10500		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10501		.channel_mode = alc883_3ST_2ch_modes,
10502		.need_dac_fix = 1,
10503		.input_mux = &alc883_lenovo_nb0763_capture_source,
10504		.unsol_event = alc_automute_amp_unsol_event,
10505		.setup = alc883_lenovo_nb0763_setup,
10506		.init_hook = alc_automute_amp,
10507	},
10508	[ALC888_LENOVO_MS7195_DIG] = {
10509		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10510		.init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10511		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10512		.dac_nids = alc883_dac_nids,
10513		.dig_out_nid = ALC883_DIGOUT_NID,
10514		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10515		.channel_mode = alc883_3ST_6ch_modes,
10516		.need_dac_fix = 1,
10517		.input_mux = &alc883_capture_source,
10518		.unsol_event = alc883_lenovo_ms7195_unsol_event,
10519		.init_hook = alc888_lenovo_ms7195_front_automute,
10520	},
10521	[ALC883_HAIER_W66] = {
10522		.mixers = { alc883_targa_2ch_mixer},
10523		.init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10524		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10525		.dac_nids = alc883_dac_nids,
10526		.dig_out_nid = ALC883_DIGOUT_NID,
10527		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10528		.channel_mode = alc883_3ST_2ch_modes,
10529		.input_mux = &alc883_capture_source,
10530		.unsol_event = alc_automute_amp_unsol_event,
10531		.setup = alc883_haier_w66_setup,
10532		.init_hook = alc_automute_amp,
10533	},
10534	[ALC888_3ST_HP] = {
10535		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10536		.init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10537		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10538		.dac_nids = alc883_dac_nids,
10539		.num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10540		.channel_mode = alc888_3st_hp_modes,
10541		.need_dac_fix = 1,
10542		.input_mux = &alc883_capture_source,
10543		.unsol_event = alc_automute_amp_unsol_event,
10544		.setup = alc888_3st_hp_setup,
10545		.init_hook = alc_automute_amp,
10546	},
10547	[ALC888_6ST_DELL] = {
10548		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10549		.init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10550		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10551		.dac_nids = alc883_dac_nids,
10552		.dig_out_nid = ALC883_DIGOUT_NID,
10553		.dig_in_nid = ALC883_DIGIN_NID,
10554		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10555		.channel_mode = alc883_sixstack_modes,
10556		.input_mux = &alc883_capture_source,
10557		.unsol_event = alc_automute_amp_unsol_event,
10558		.setup = alc888_6st_dell_setup,
10559		.init_hook = alc_automute_amp,
10560	},
10561	[ALC883_MITAC] = {
10562		.mixers = { alc883_mitac_mixer },
10563		.init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10564		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10565		.dac_nids = alc883_dac_nids,
10566		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10567		.channel_mode = alc883_3ST_2ch_modes,
10568		.input_mux = &alc883_capture_source,
10569		.unsol_event = alc_automute_amp_unsol_event,
10570		.setup = alc883_mitac_setup,
10571		.init_hook = alc_automute_amp,
10572	},
10573	[ALC883_FUJITSU_PI2515] = {
10574		.mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10575		.init_verbs = { alc883_init_verbs,
10576				alc883_2ch_fujitsu_pi2515_verbs},
10577		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10578		.dac_nids = alc883_dac_nids,
10579		.dig_out_nid = ALC883_DIGOUT_NID,
10580		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10581		.channel_mode = alc883_3ST_2ch_modes,
10582		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10583		.unsol_event = alc_automute_amp_unsol_event,
10584		.setup = alc883_2ch_fujitsu_pi2515_setup,
10585		.init_hook = alc_automute_amp,
10586	},
10587	[ALC888_FUJITSU_XA3530] = {
10588		.mixers = { alc888_base_mixer, alc883_chmode_mixer },
10589		.init_verbs = { alc883_init_verbs,
10590			alc888_fujitsu_xa3530_verbs },
10591		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10592		.dac_nids = alc883_dac_nids,
10593		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10594		.adc_nids = alc883_adc_nids_rev,
10595		.capsrc_nids = alc883_capsrc_nids_rev,
10596		.dig_out_nid = ALC883_DIGOUT_NID,
10597		.num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10598		.channel_mode = alc888_4ST_8ch_intel_modes,
10599		.num_mux_defs =
10600			ARRAY_SIZE(alc888_2_capture_sources),
10601		.input_mux = alc888_2_capture_sources,
10602		.unsol_event = alc_automute_amp_unsol_event,
10603		.setup = alc888_fujitsu_xa3530_setup,
10604		.init_hook = alc_automute_amp,
10605	},
10606	[ALC888_LENOVO_SKY] = {
10607		.mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10608		.init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10609		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10610		.dac_nids = alc883_dac_nids,
10611		.dig_out_nid = ALC883_DIGOUT_NID,
10612		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10613		.channel_mode = alc883_sixstack_modes,
10614		.need_dac_fix = 1,
10615		.input_mux = &alc883_lenovo_sky_capture_source,
10616		.unsol_event = alc_automute_amp_unsol_event,
10617		.setup = alc888_lenovo_sky_setup,
10618		.init_hook = alc_automute_amp,
10619	},
10620	[ALC888_ASUS_M90V] = {
10621		.mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10622		.init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10623		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10624		.dac_nids = alc883_dac_nids,
10625		.dig_out_nid = ALC883_DIGOUT_NID,
10626		.dig_in_nid = ALC883_DIGIN_NID,
10627		.num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10628		.channel_mode = alc883_3ST_6ch_modes,
10629		.need_dac_fix = 1,
10630		.input_mux = &alc883_fujitsu_pi2515_capture_source,
10631		.unsol_event = alc_sku_unsol_event,
10632		.setup = alc883_mode2_setup,
10633		.init_hook = alc_inithook,
10634	},
10635	[ALC888_ASUS_EEE1601] = {
10636		.mixers = { alc883_asus_eee1601_mixer },
10637		.cap_mixer = alc883_asus_eee1601_cap_mixer,
10638		.init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10639		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10640		.dac_nids = alc883_dac_nids,
10641		.dig_out_nid = ALC883_DIGOUT_NID,
10642		.dig_in_nid = ALC883_DIGIN_NID,
10643		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10644		.channel_mode = alc883_3ST_2ch_modes,
10645		.need_dac_fix = 1,
10646		.input_mux = &alc883_asus_eee1601_capture_source,
10647		.unsol_event = alc_sku_unsol_event,
10648		.init_hook = alc883_eee1601_inithook,
10649	},
10650	[ALC1200_ASUS_P5Q] = {
10651		.mixers = { alc883_base_mixer, alc883_chmode_mixer },
10652		.init_verbs = { alc883_init_verbs },
10653		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10654		.dac_nids = alc883_dac_nids,
10655		.dig_out_nid = ALC1200_DIGOUT_NID,
10656		.dig_in_nid = ALC883_DIGIN_NID,
10657		.slave_dig_outs = alc1200_slave_dig_outs,
10658		.num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10659		.channel_mode = alc883_sixstack_modes,
10660		.input_mux = &alc883_capture_source,
10661	},
10662	[ALC889A_MB31] = {
10663		.mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10664		.init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10665			alc880_gpio1_init_verbs },
10666		.adc_nids = alc883_adc_nids,
10667		.num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10668		.capsrc_nids = alc883_capsrc_nids,
10669		.dac_nids = alc883_dac_nids,
10670		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10671		.channel_mode = alc889A_mb31_6ch_modes,
10672		.num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10673		.input_mux = &alc889A_mb31_capture_source,
10674		.dig_out_nid = ALC883_DIGOUT_NID,
10675		.unsol_event = alc889A_mb31_unsol_event,
10676		.init_hook = alc889A_mb31_automute,
10677	},
10678	[ALC883_SONY_VAIO_TT] = {
10679		.mixers = { alc883_vaiott_mixer },
10680		.init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10681		.num_dacs = ARRAY_SIZE(alc883_dac_nids),
10682		.dac_nids = alc883_dac_nids,
10683		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10684		.channel_mode = alc883_3ST_2ch_modes,
10685		.input_mux = &alc883_capture_source,
10686		.unsol_event = alc_automute_amp_unsol_event,
10687		.setup = alc883_vaiott_setup,
10688		.init_hook = alc_automute_amp,
10689	},
10690};
10691
10692
10693/*
10694 * Pin config fixes
10695 */
10696enum {
10697	PINFIX_ABIT_AW9D_MAX,
10698	PINFIX_LENOVO_Y530,
10699	PINFIX_PB_M5210,
10700	PINFIX_ACER_ASPIRE_7736,
10701};
10702
10703static const struct alc_fixup alc882_fixups[] = {
10704	[PINFIX_ABIT_AW9D_MAX] = {
10705		.type = ALC_FIXUP_PINS,
10706		.v.pins = (const struct alc_pincfg[]) {
10707			{ 0x15, 0x01080104 }, /* side */
10708			{ 0x16, 0x01011012 }, /* rear */
10709			{ 0x17, 0x01016011 }, /* clfe */
10710			{ }
10711		}
10712	},
10713	[PINFIX_LENOVO_Y530] = {
10714		.type = ALC_FIXUP_PINS,
10715		.v.pins = (const struct alc_pincfg[]) {
10716			{ 0x15, 0x99130112 }, /* rear int speakers */
10717			{ 0x16, 0x99130111 }, /* subwoofer */
10718			{ }
10719		}
10720	},
10721	[PINFIX_PB_M5210] = {
10722		.type = ALC_FIXUP_VERBS,
10723		.v.verbs = (const struct hda_verb[]) {
10724			{ 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10725			{}
10726		}
10727	},
10728	[PINFIX_ACER_ASPIRE_7736] = {
10729		.type = ALC_FIXUP_SKU,
10730		.v.sku = ALC_FIXUP_SKU_IGNORE,
10731	},
10732};
10733
10734static struct snd_pci_quirk alc882_fixup_tbl[] = {
10735	SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10736	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Y530", PINFIX_LENOVO_Y530),
10737	SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10738	SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736),
10739	{}
10740};
10741
10742/*
10743 * BIOS auto configuration
10744 */
10745static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10746						const struct auto_pin_cfg *cfg)
10747{
10748	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10749}
10750
10751static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10752					      hda_nid_t nid, int pin_type,
10753					      hda_nid_t dac)
10754{
10755	int idx;
10756
10757	/* set as output */
10758	alc_set_pin_output(codec, nid, pin_type);
10759
10760	if (dac == 0x25)
10761		idx = 4;
10762	else if (dac >= 0x02 && dac <= 0x05)
10763		idx = dac - 2;
10764	else
10765		return;
10766	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10767}
10768
10769static void alc882_auto_init_multi_out(struct hda_codec *codec)
10770{
10771	struct alc_spec *spec = codec->spec;
10772	int i;
10773
10774	for (i = 0; i <= HDA_SIDE; i++) {
10775		hda_nid_t nid = spec->autocfg.line_out_pins[i];
10776		int pin_type = get_pin_type(spec->autocfg.line_out_type);
10777		if (nid)
10778			alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10779					spec->multiout.dac_nids[i]);
10780	}
10781}
10782
10783static void alc882_auto_init_hp_out(struct hda_codec *codec)
10784{
10785	struct alc_spec *spec = codec->spec;
10786	hda_nid_t pin, dac;
10787	int i;
10788
10789	if (spec->autocfg.line_out_type != AUTO_PIN_HP_OUT) {
10790		for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
10791			pin = spec->autocfg.hp_pins[i];
10792			if (!pin)
10793				break;
10794			dac = spec->multiout.hp_nid;
10795			if (!dac)
10796				dac = spec->multiout.dac_nids[0]; /* to front */
10797			alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10798		}
10799	}
10800
10801	if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT) {
10802		for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
10803			pin = spec->autocfg.speaker_pins[i];
10804			if (!pin)
10805				break;
10806			dac = spec->multiout.extra_out_nid[0];
10807			if (!dac)
10808				dac = spec->multiout.dac_nids[0]; /* to front */
10809			alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10810		}
10811	}
10812}
10813
10814static void alc882_auto_init_analog_input(struct hda_codec *codec)
10815{
10816	struct alc_spec *spec = codec->spec;
10817	struct auto_pin_cfg *cfg = &spec->autocfg;
10818	int i;
10819
10820	for (i = 0; i < cfg->num_inputs; i++) {
10821		hda_nid_t nid = cfg->inputs[i].pin;
10822		alc_set_input_pin(codec, nid, cfg->inputs[i].type);
10823		if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10824			snd_hda_codec_write(codec, nid, 0,
10825					    AC_VERB_SET_AMP_GAIN_MUTE,
10826					    AMP_OUT_MUTE);
10827	}
10828}
10829
10830static void alc882_auto_init_input_src(struct hda_codec *codec)
10831{
10832	struct alc_spec *spec = codec->spec;
10833	int c;
10834
10835	for (c = 0; c < spec->num_adc_nids; c++) {
10836		hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10837		hda_nid_t nid = spec->capsrc_nids[c];
10838		unsigned int mux_idx;
10839		const struct hda_input_mux *imux;
10840		int conns, mute, idx, item;
10841
10842		conns = snd_hda_get_connections(codec, nid, conn_list,
10843						ARRAY_SIZE(conn_list));
10844		if (conns < 0)
10845			continue;
10846		mux_idx = c >= spec->num_mux_defs ? 0 : c;
10847		imux = &spec->input_mux[mux_idx];
10848		if (!imux->num_items && mux_idx > 0)
10849			imux = &spec->input_mux[0];
10850		for (idx = 0; idx < conns; idx++) {
10851			/* if the current connection is the selected one,
10852			 * unmute it as default - otherwise mute it
10853			 */
10854			mute = AMP_IN_MUTE(idx);
10855			for (item = 0; item < imux->num_items; item++) {
10856				if (imux->items[item].index == idx) {
10857					if (spec->cur_mux[c] == item)
10858						mute = AMP_IN_UNMUTE(idx);
10859					break;
10860				}
10861			}
10862			/* check if we have a selector or mixer
10863			 * we could check for the widget type instead, but
10864			 * just check for Amp-In presence (in case of mixer
10865			 * without amp-in there is something wrong, this
10866			 * function shouldn't be used or capsrc nid is wrong)
10867			 */
10868			if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10869				snd_hda_codec_write(codec, nid, 0,
10870						    AC_VERB_SET_AMP_GAIN_MUTE,
10871						    mute);
10872			else if (mute != AMP_IN_MUTE(idx))
10873				snd_hda_codec_write(codec, nid, 0,
10874						    AC_VERB_SET_CONNECT_SEL,
10875						    idx);
10876		}
10877	}
10878}
10879
10880/* add mic boosts if needed */
10881static int alc_auto_add_mic_boost(struct hda_codec *codec)
10882{
10883	struct alc_spec *spec = codec->spec;
10884	struct auto_pin_cfg *cfg = &spec->autocfg;
10885	int i, err;
10886	int type_idx = 0;
10887	hda_nid_t nid;
10888	const char *prev_label = NULL;
10889
10890	for (i = 0; i < cfg->num_inputs; i++) {
10891		if (cfg->inputs[i].type > AUTO_PIN_MIC)
10892			break;
10893		nid = cfg->inputs[i].pin;
10894		if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10895			const char *label;
10896			char boost_label[32];
10897
10898			label = hda_get_autocfg_input_label(codec, cfg, i);
10899			if (prev_label && !strcmp(label, prev_label))
10900				type_idx++;
10901			else
10902				type_idx = 0;
10903			prev_label = label;
10904
10905			snprintf(boost_label, sizeof(boost_label),
10906				 "%s Boost Volume", label);
10907			err = add_control(spec, ALC_CTL_WIDGET_VOL,
10908					  boost_label, type_idx,
10909				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10910			if (err < 0)
10911				return err;
10912		}
10913	}
10914	return 0;
10915}
10916
10917/* almost identical with ALC880 parser... */
10918static int alc882_parse_auto_config(struct hda_codec *codec)
10919{
10920	struct alc_spec *spec = codec->spec;
10921	static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10922	int err;
10923
10924	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10925					   alc882_ignore);
10926	if (err < 0)
10927		return err;
10928	if (!spec->autocfg.line_outs)
10929		return 0; /* can't find valid BIOS pin config */
10930
10931	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10932	if (err < 0)
10933		return err;
10934	err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10935	if (err < 0)
10936		return err;
10937	err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10938					   "Headphone");
10939	if (err < 0)
10940		return err;
10941	err = alc880_auto_create_extra_out(spec,
10942					   spec->autocfg.speaker_pins[0],
10943					   "Speaker");
10944	if (err < 0)
10945		return err;
10946	err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10947	if (err < 0)
10948		return err;
10949
10950	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10951
10952	alc_auto_parse_digital(codec);
10953
10954	if (spec->kctls.list)
10955		add_mixer(spec, spec->kctls.list);
10956
10957	add_verb(spec, alc883_auto_init_verbs);
10958	/* if ADC 0x07 is available, initialize it, too */
10959	if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10960		add_verb(spec, alc882_adc1_init_verbs);
10961
10962	spec->num_mux_defs = 1;
10963	spec->input_mux = &spec->private_imux[0];
10964
10965	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10966
10967	err = alc_auto_add_mic_boost(codec);
10968	if (err < 0)
10969		return err;
10970
10971	return 1; /* config found */
10972}
10973
10974/* additional initialization for auto-configuration model */
10975static void alc882_auto_init(struct hda_codec *codec)
10976{
10977	struct alc_spec *spec = codec->spec;
10978	alc882_auto_init_multi_out(codec);
10979	alc882_auto_init_hp_out(codec);
10980	alc882_auto_init_analog_input(codec);
10981	alc882_auto_init_input_src(codec);
10982	alc_auto_init_digital(codec);
10983	if (spec->unsol_event)
10984		alc_inithook(codec);
10985}
10986
10987static int patch_alc882(struct hda_codec *codec)
10988{
10989	struct alc_spec *spec;
10990	int err, board_config;
10991
10992	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10993	if (spec == NULL)
10994		return -ENOMEM;
10995
10996	codec->spec = spec;
10997
10998	switch (codec->vendor_id) {
10999	case 0x10ec0882:
11000	case 0x10ec0885:
11001		break;
11002	default:
11003		/* ALC883 and variants */
11004		alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11005		break;
11006	}
11007
11008	board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
11009						  alc882_models,
11010						  alc882_cfg_tbl);
11011
11012	if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
11013		board_config = snd_hda_check_board_codec_sid_config(codec,
11014			ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
11015
11016	if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
11017		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11018		       codec->chip_name);
11019		board_config = ALC882_AUTO;
11020	}
11021
11022	if (board_config == ALC882_AUTO) {
11023		alc_pick_fixup(codec, NULL, alc882_fixup_tbl, alc882_fixups);
11024		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
11025	}
11026
11027	alc_auto_parse_customize_define(codec);
11028
11029	if (board_config == ALC882_AUTO) {
11030		/* automatic parse from the BIOS config */
11031		err = alc882_parse_auto_config(codec);
11032		if (err < 0) {
11033			alc_free(codec);
11034			return err;
11035		} else if (!err) {
11036			printk(KERN_INFO
11037			       "hda_codec: Cannot set up configuration "
11038			       "from BIOS.  Using base mode...\n");
11039			board_config = ALC882_3ST_DIG;
11040		}
11041	}
11042
11043	if (has_cdefine_beep(codec)) {
11044		err = snd_hda_attach_beep_device(codec, 0x1);
11045		if (err < 0) {
11046			alc_free(codec);
11047			return err;
11048		}
11049	}
11050
11051	if (board_config != ALC882_AUTO)
11052		setup_preset(codec, &alc882_presets[board_config]);
11053
11054	spec->stream_analog_playback = &alc882_pcm_analog_playback;
11055	spec->stream_analog_capture = &alc882_pcm_analog_capture;
11056	/* FIXME: setup DAC5 */
11057	/*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
11058	spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
11059
11060	spec->stream_digital_playback = &alc882_pcm_digital_playback;
11061	spec->stream_digital_capture = &alc882_pcm_digital_capture;
11062
11063	if (!spec->adc_nids && spec->input_mux) {
11064		int i, j;
11065		spec->num_adc_nids = 0;
11066		for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
11067			const struct hda_input_mux *imux = spec->input_mux;
11068			hda_nid_t cap;
11069			hda_nid_t items[16];
11070			hda_nid_t nid = alc882_adc_nids[i];
11071			unsigned int wcap = get_wcaps(codec, nid);
11072			/* get type */
11073			wcap = get_wcaps_type(wcap);
11074			if (wcap != AC_WID_AUD_IN)
11075				continue;
11076			spec->private_adc_nids[spec->num_adc_nids] = nid;
11077			err = snd_hda_get_connections(codec, nid, &cap, 1);
11078			if (err < 0)
11079				continue;
11080			err = snd_hda_get_connections(codec, cap, items,
11081						      ARRAY_SIZE(items));
11082			if (err < 0)
11083				continue;
11084			for (j = 0; j < imux->num_items; j++)
11085				if (imux->items[j].index >= err)
11086					break;
11087			if (j < imux->num_items)
11088				continue;
11089			spec->private_capsrc_nids[spec->num_adc_nids] = cap;
11090			spec->num_adc_nids++;
11091		}
11092		spec->adc_nids = spec->private_adc_nids;
11093		spec->capsrc_nids = spec->private_capsrc_nids;
11094	}
11095
11096	set_capture_mixer(codec);
11097
11098	if (has_cdefine_beep(codec))
11099		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11100
11101	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
11102
11103	spec->vmaster_nid = 0x0c;
11104
11105	codec->patch_ops = alc_patch_ops;
11106	if (board_config == ALC882_AUTO)
11107		spec->init_hook = alc882_auto_init;
11108
11109	alc_init_jacks(codec);
11110#ifdef CONFIG_SND_HDA_POWER_SAVE
11111	if (!spec->loopback.amplist)
11112		spec->loopback.amplist = alc882_loopbacks;
11113#endif
11114
11115	return 0;
11116}
11117
11118
11119/*
11120 * ALC262 support
11121 */
11122
11123#define ALC262_DIGOUT_NID	ALC880_DIGOUT_NID
11124#define ALC262_DIGIN_NID	ALC880_DIGIN_NID
11125
11126#define alc262_dac_nids		alc260_dac_nids
11127#define alc262_adc_nids		alc882_adc_nids
11128#define alc262_adc_nids_alt	alc882_adc_nids_alt
11129#define alc262_capsrc_nids	alc882_capsrc_nids
11130#define alc262_capsrc_nids_alt	alc882_capsrc_nids_alt
11131
11132#define alc262_modes		alc260_modes
11133#define alc262_capture_source	alc882_capture_source
11134
11135static hda_nid_t alc262_dmic_adc_nids[1] = {
11136	/* ADC0 */
11137	0x09
11138};
11139
11140static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
11141
11142static struct snd_kcontrol_new alc262_base_mixer[] = {
11143	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11144	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11145	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11146	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11147	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11148	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11149	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11150	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11151	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11152	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11153	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11154	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11155	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
11156	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11157	HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
11158	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
11159	{ } /* end */
11160};
11161
11162/* update HP, line and mono-out pins according to the master switch */
11163static void alc262_hp_master_update(struct hda_codec *codec)
11164{
11165	struct alc_spec *spec = codec->spec;
11166	int val = spec->master_sw;
11167
11168	/* HP & line-out */
11169	snd_hda_codec_write_cache(codec, 0x1b, 0,
11170				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11171				  val ? PIN_HP : 0);
11172	snd_hda_codec_write_cache(codec, 0x15, 0,
11173				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11174				  val ? PIN_HP : 0);
11175	/* mono (speaker) depending on the HP jack sense */
11176	val = val && !spec->jack_present;
11177	snd_hda_codec_write_cache(codec, 0x16, 0,
11178				  AC_VERB_SET_PIN_WIDGET_CONTROL,
11179				  val ? PIN_OUT : 0);
11180}
11181
11182static void alc262_hp_bpc_automute(struct hda_codec *codec)
11183{
11184	struct alc_spec *spec = codec->spec;
11185
11186	spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11187	alc262_hp_master_update(codec);
11188}
11189
11190static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
11191{
11192	if ((res >> 26) != ALC880_HP_EVENT)
11193		return;
11194	alc262_hp_bpc_automute(codec);
11195}
11196
11197static void alc262_hp_wildwest_automute(struct hda_codec *codec)
11198{
11199	struct alc_spec *spec = codec->spec;
11200
11201	spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11202	alc262_hp_master_update(codec);
11203}
11204
11205static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
11206					   unsigned int res)
11207{
11208	if ((res >> 26) != ALC880_HP_EVENT)
11209		return;
11210	alc262_hp_wildwest_automute(codec);
11211}
11212
11213#define alc262_hp_master_sw_get		alc260_hp_master_sw_get
11214
11215static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
11216				   struct snd_ctl_elem_value *ucontrol)
11217{
11218	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11219	struct alc_spec *spec = codec->spec;
11220	int val = !!*ucontrol->value.integer.value;
11221
11222	if (val == spec->master_sw)
11223		return 0;
11224	spec->master_sw = val;
11225	alc262_hp_master_update(codec);
11226	return 1;
11227}
11228
11229#define ALC262_HP_MASTER_SWITCH					\
11230	{							\
11231		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
11232		.name = "Master Playback Switch",		\
11233		.info = snd_ctl_boolean_mono_info,		\
11234		.get = alc262_hp_master_sw_get,			\
11235		.put = alc262_hp_master_sw_put,			\
11236	}, \
11237	{							\
11238		.iface = NID_MAPPING,				\
11239		.name = "Master Playback Switch",		\
11240		.private_value = 0x15 | (0x16 << 8) | (0x1b << 16),	\
11241	}
11242
11243
11244static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
11245	ALC262_HP_MASTER_SWITCH,
11246	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11247	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11248	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11249	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11250			      HDA_OUTPUT),
11251	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11252			    HDA_OUTPUT),
11253	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11254	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11255	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11256	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11257	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11258	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11259	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11260	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11261	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11262	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11263	HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
11264	HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
11265	{ } /* end */
11266};
11267
11268static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
11269	ALC262_HP_MASTER_SWITCH,
11270	HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11271	HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11272	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11273	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11274	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
11275			      HDA_OUTPUT),
11276	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
11277			    HDA_OUTPUT),
11278	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11279	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11280	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x1a, 0, HDA_INPUT),
11281	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11282	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11283	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11284	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11285	{ } /* end */
11286};
11287
11288static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11289	HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11290	HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11291	HDA_CODEC_VOLUME("Rear Mic Boost Volume", 0x18, 0, HDA_INPUT),
11292	{ } /* end */
11293};
11294
11295/* mute/unmute internal speaker according to the hp jack and mute state */
11296static void alc262_hp_t5735_setup(struct hda_codec *codec)
11297{
11298	struct alc_spec *spec = codec->spec;
11299
11300	spec->autocfg.hp_pins[0] = 0x15;
11301	spec->autocfg.speaker_pins[0] = 0x14;
11302}
11303
11304static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11305	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11306	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11307	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11308	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11309	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11310	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11311	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11312	{ } /* end */
11313};
11314
11315static struct hda_verb alc262_hp_t5735_verbs[] = {
11316	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11317	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11318
11319	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11320	{ }
11321};
11322
11323static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11324	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11325	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11326	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11327	HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11328	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11329	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11330	{ } /* end */
11331};
11332
11333static struct hda_verb alc262_hp_rp5700_verbs[] = {
11334	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11335	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11336	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11337	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11338	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11339	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11340	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11341	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11342	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11343	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11344	{}
11345};
11346
11347static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11348	.num_items = 1,
11349	.items = {
11350		{ "Line", 0x1 },
11351	},
11352};
11353
11354/* bind hp and internal speaker mute (with plug check) as master switch */
11355static void alc262_hippo_master_update(struct hda_codec *codec)
11356{
11357	struct alc_spec *spec = codec->spec;
11358	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11359	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11360	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11361	unsigned int mute;
11362
11363	/* HP */
11364	mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11365	snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11366				 HDA_AMP_MUTE, mute);
11367	/* mute internal speaker per jack sense */
11368	if (spec->jack_present)
11369		mute = HDA_AMP_MUTE;
11370	if (line_nid)
11371		snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11372					 HDA_AMP_MUTE, mute);
11373	if (speaker_nid && speaker_nid != line_nid)
11374		snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11375					 HDA_AMP_MUTE, mute);
11376}
11377
11378#define alc262_hippo_master_sw_get	alc262_hp_master_sw_get
11379
11380static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11381				      struct snd_ctl_elem_value *ucontrol)
11382{
11383	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11384	struct alc_spec *spec = codec->spec;
11385	int val = !!*ucontrol->value.integer.value;
11386
11387	if (val == spec->master_sw)
11388		return 0;
11389	spec->master_sw = val;
11390	alc262_hippo_master_update(codec);
11391	return 1;
11392}
11393
11394#define ALC262_HIPPO_MASTER_SWITCH				\
11395	{							\
11396		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,		\
11397		.name = "Master Playback Switch",		\
11398		.info = snd_ctl_boolean_mono_info,		\
11399		.get = alc262_hippo_master_sw_get,		\
11400		.put = alc262_hippo_master_sw_put,		\
11401	},							\
11402	{							\
11403		.iface = NID_MAPPING,				\
11404		.name = "Master Playback Switch",		\
11405		.subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11406			     (SUBDEV_SPEAKER(0) << 16), \
11407	}
11408
11409static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11410	ALC262_HIPPO_MASTER_SWITCH,
11411	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11412	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11413	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11414	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11415	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11416	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11417	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11418	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11419	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11420	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11421	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11422	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11423	{ } /* end */
11424};
11425
11426static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11427	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11428	ALC262_HIPPO_MASTER_SWITCH,
11429	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11430	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11431	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11432	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11433	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11434	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11435	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11436	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11437	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11438	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11439	{ } /* end */
11440};
11441
11442/* mute/unmute internal speaker according to the hp jack and mute state */
11443static void alc262_hippo_automute(struct hda_codec *codec)
11444{
11445	struct alc_spec *spec = codec->spec;
11446	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11447
11448	spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11449	alc262_hippo_master_update(codec);
11450}
11451
11452static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11453{
11454	if ((res >> 26) != ALC880_HP_EVENT)
11455		return;
11456	alc262_hippo_automute(codec);
11457}
11458
11459static void alc262_hippo_setup(struct hda_codec *codec)
11460{
11461	struct alc_spec *spec = codec->spec;
11462
11463	spec->autocfg.hp_pins[0] = 0x15;
11464	spec->autocfg.speaker_pins[0] = 0x14;
11465}
11466
11467static void alc262_hippo1_setup(struct hda_codec *codec)
11468{
11469	struct alc_spec *spec = codec->spec;
11470
11471	spec->autocfg.hp_pins[0] = 0x1b;
11472	spec->autocfg.speaker_pins[0] = 0x14;
11473}
11474
11475
11476static struct snd_kcontrol_new alc262_sony_mixer[] = {
11477	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11478	ALC262_HIPPO_MASTER_SWITCH,
11479	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11480	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11481	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11482	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11483	{ } /* end */
11484};
11485
11486static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11487	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11488	ALC262_HIPPO_MASTER_SWITCH,
11489	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11490	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11491	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11492	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11493	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11494	{ } /* end */
11495};
11496
11497static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11498	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11499	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11500	HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11501	HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11502	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11503	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11504	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11505	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11506	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11507	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11508	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11509	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11510	{ } /* end */
11511};
11512
11513static struct hda_verb alc262_tyan_verbs[] = {
11514	/* Headphone automute */
11515	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11516	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11517	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11518
11519	/* P11 AUX_IN, white 4-pin connector */
11520	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11521	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11522	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11523	{0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11524
11525	{}
11526};
11527
11528/* unsolicited event for HP jack sensing */
11529static void alc262_tyan_setup(struct hda_codec *codec)
11530{
11531	struct alc_spec *spec = codec->spec;
11532
11533	spec->autocfg.hp_pins[0] = 0x1b;
11534	spec->autocfg.speaker_pins[0] = 0x15;
11535}
11536
11537
11538#define alc262_capture_mixer		alc882_capture_mixer
11539#define alc262_capture_alt_mixer	alc882_capture_alt_mixer
11540
11541/*
11542 * generic initialization of ADC, input mixers and output mixers
11543 */
11544static struct hda_verb alc262_init_verbs[] = {
11545	/*
11546	 * Unmute ADC0-2 and set the default input to mic-in
11547	 */
11548	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11549	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11550	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11551	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11552	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11553	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11554
11555	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11556	 * mixer widget
11557	 * Note: PASD motherboards uses the Line In 2 as the input for
11558	 * front panel mic (mic 2)
11559	 */
11560	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11561	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11562	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11563	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11564	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11565	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11566
11567	/*
11568	 * Set up output mixers (0x0c - 0x0e)
11569	 */
11570	/* set vol=0 to output mixers */
11571	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11572	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11573	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11574	/* set up input amps for analog loopback */
11575	/* Amp Indices: DAC = 0, mixer = 1 */
11576	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11577	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11578	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11579	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11580	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11581	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11582
11583	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11584	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11585	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11586	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11587	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11588	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11589
11590	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11591	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11592	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11593	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11594	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11595
11596	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11597	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11598
11599	/* FIXME: use matrix-type input source selection */
11600	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11601	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11602	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11603	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11604	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11605	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11606	/* Input mixer2 */
11607	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11608	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11609	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11610	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11611	/* Input mixer3 */
11612	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11613	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11614	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11615	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11616
11617	{ }
11618};
11619
11620static struct hda_verb alc262_eapd_verbs[] = {
11621	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11622	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11623	{ }
11624};
11625
11626static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11627	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11628	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11629	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11630
11631	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11632	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11633	{}
11634};
11635
11636static struct hda_verb alc262_sony_unsol_verbs[] = {
11637	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11638	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11639	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},	// Front Mic
11640
11641	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11642	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11643	{}
11644};
11645
11646static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11647	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11648	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11649	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11650	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11651	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11652	{ } /* end */
11653};
11654
11655static struct hda_verb alc262_toshiba_s06_verbs[] = {
11656	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11657	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11658	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11659	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11660	{0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11661	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11662	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11663	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11664	{}
11665};
11666
11667static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11668{
11669	struct alc_spec *spec = codec->spec;
11670
11671	spec->autocfg.hp_pins[0] = 0x15;
11672	spec->autocfg.speaker_pins[0] = 0x14;
11673	spec->ext_mic.pin = 0x18;
11674	spec->ext_mic.mux_idx = 0;
11675	spec->int_mic.pin = 0x12;
11676	spec->int_mic.mux_idx = 9;
11677	spec->auto_mic = 1;
11678}
11679
11680/*
11681 * nec model
11682 *  0x15 = headphone
11683 *  0x16 = internal speaker
11684 *  0x18 = external mic
11685 */
11686
11687static struct snd_kcontrol_new alc262_nec_mixer[] = {
11688	HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11689	HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11690
11691	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11692	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11693	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11694
11695	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11696	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11697	{ } /* end */
11698};
11699
11700static struct hda_verb alc262_nec_verbs[] = {
11701	/* Unmute Speaker */
11702	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11703
11704	/* Headphone */
11705	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11706	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11707
11708	/* External mic to headphone */
11709	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11710	/* External mic to speaker */
11711	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11712	{}
11713};
11714
11715/*
11716 * fujitsu model
11717 *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11718 *  0x1b = port replicator headphone out
11719 */
11720
11721#define ALC_HP_EVENT	0x37
11722
11723static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11724	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11725	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11726	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11727	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11728	{}
11729};
11730
11731static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11732	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11733	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11734	{}
11735};
11736
11737static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11738	/* Front Mic pin: input vref at 50% */
11739	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11740	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11741	{}
11742};
11743
11744static struct hda_input_mux alc262_fujitsu_capture_source = {
11745	.num_items = 3,
11746	.items = {
11747		{ "Mic", 0x0 },
11748		{ "Internal Mic", 0x1 },
11749		{ "CD", 0x4 },
11750	},
11751};
11752
11753static struct hda_input_mux alc262_HP_capture_source = {
11754	.num_items = 5,
11755	.items = {
11756		{ "Mic", 0x0 },
11757		{ "Front Mic", 0x1 },
11758		{ "Line", 0x2 },
11759		{ "CD", 0x4 },
11760		{ "AUX IN", 0x6 },
11761	},
11762};
11763
11764static struct hda_input_mux alc262_HP_D7000_capture_source = {
11765	.num_items = 4,
11766	.items = {
11767		{ "Mic", 0x0 },
11768		{ "Front Mic", 0x2 },
11769		{ "Line", 0x1 },
11770		{ "CD", 0x4 },
11771	},
11772};
11773
11774/* mute/unmute internal speaker according to the hp jacks and mute state */
11775static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11776{
11777	struct alc_spec *spec = codec->spec;
11778	unsigned int mute;
11779
11780	if (force || !spec->sense_updated) {
11781		spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11782				     snd_hda_jack_detect(codec, 0x1b);
11783		spec->sense_updated = 1;
11784	}
11785	/* unmute internal speaker only if both HPs are unplugged and
11786	 * master switch is on
11787	 */
11788	if (spec->jack_present)
11789		mute = HDA_AMP_MUTE;
11790	else
11791		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11792	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11793				 HDA_AMP_MUTE, mute);
11794}
11795
11796/* unsolicited event for HP jack sensing */
11797static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11798				       unsigned int res)
11799{
11800	if ((res >> 26) != ALC_HP_EVENT)
11801		return;
11802	alc262_fujitsu_automute(codec, 1);
11803}
11804
11805static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11806{
11807	alc262_fujitsu_automute(codec, 1);
11808}
11809
11810/* bind volumes of both NID 0x0c and 0x0d */
11811static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11812	.ops = &snd_hda_bind_vol,
11813	.values = {
11814		HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11815		HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11816		0
11817	},
11818};
11819
11820/* mute/unmute internal speaker according to the hp jack and mute state */
11821static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11822{
11823	struct alc_spec *spec = codec->spec;
11824	unsigned int mute;
11825
11826	if (force || !spec->sense_updated) {
11827		spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11828		spec->sense_updated = 1;
11829	}
11830	if (spec->jack_present) {
11831		/* mute internal speaker */
11832		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11833					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11834		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11835					 HDA_AMP_MUTE, HDA_AMP_MUTE);
11836	} else {
11837		/* unmute internal speaker if necessary */
11838		mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11839		snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11840					 HDA_AMP_MUTE, mute);
11841		snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11842					 HDA_AMP_MUTE, mute);
11843	}
11844}
11845
11846/* unsolicited event for HP jack sensing */
11847static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11848				       unsigned int res)
11849{
11850	if ((res >> 26) != ALC_HP_EVENT)
11851		return;
11852	alc262_lenovo_3000_automute(codec, 1);
11853}
11854
11855static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11856				  int dir, int idx, long *valp)
11857{
11858	int i, change = 0;
11859
11860	for (i = 0; i < 2; i++, valp++)
11861		change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11862						   HDA_AMP_MUTE,
11863						   *valp ? 0 : HDA_AMP_MUTE);
11864	return change;
11865}
11866
11867/* bind hp and internal speaker mute (with plug check) */
11868static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11869					 struct snd_ctl_elem_value *ucontrol)
11870{
11871	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11872	long *valp = ucontrol->value.integer.value;
11873	int change;
11874
11875	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11876	change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11877	if (change)
11878		alc262_fujitsu_automute(codec, 0);
11879	return change;
11880}
11881
11882static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11883	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11884	{
11885		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11886		.name = "Master Playback Switch",
11887		.subdevice = HDA_SUBDEV_AMP_FLAG,
11888		.info = snd_hda_mixer_amp_switch_info,
11889		.get = snd_hda_mixer_amp_switch_get,
11890		.put = alc262_fujitsu_master_sw_put,
11891		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11892	},
11893	{
11894		.iface = NID_MAPPING,
11895		.name = "Master Playback Switch",
11896		.private_value = 0x1b,
11897	},
11898	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11899	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11900	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11901	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11902	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11903	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11904	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11905	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11906	{ } /* end */
11907};
11908
11909/* bind hp and internal speaker mute (with plug check) */
11910static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11911					 struct snd_ctl_elem_value *ucontrol)
11912{
11913	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11914	long *valp = ucontrol->value.integer.value;
11915	int change;
11916
11917	change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11918	if (change)
11919		alc262_lenovo_3000_automute(codec, 0);
11920	return change;
11921}
11922
11923static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11924	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11925	{
11926		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11927		.name = "Master Playback Switch",
11928		.subdevice = HDA_SUBDEV_AMP_FLAG,
11929		.info = snd_hda_mixer_amp_switch_info,
11930		.get = snd_hda_mixer_amp_switch_get,
11931		.put = alc262_lenovo_3000_master_sw_put,
11932		.private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11933	},
11934	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11935	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11936	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11937	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11938	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11939	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
11940	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11941	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11942	{ } /* end */
11943};
11944
11945static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11946	HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11947	ALC262_HIPPO_MASTER_SWITCH,
11948	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11949	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11950	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
11951	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11952	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11953	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
11954	{ } /* end */
11955};
11956
11957/* additional init verbs for Benq laptops */
11958static struct hda_verb alc262_EAPD_verbs[] = {
11959	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11960	{0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11961	{}
11962};
11963
11964static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11965	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11966	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11967
11968	{0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11969	{0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11970	{}
11971};
11972
11973/* Samsung Q1 Ultra Vista model setup */
11974static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11975	HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11976	HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11977	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11978	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11979	HDA_CODEC_VOLUME("Mic Boost Volume", 0x19, 0, HDA_INPUT),
11980	HDA_CODEC_VOLUME("Headphone Mic Boost Volume", 0x15, 0, HDA_INPUT),
11981	{ } /* end */
11982};
11983
11984static struct hda_verb alc262_ultra_verbs[] = {
11985	/* output mixer */
11986	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11987	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11988	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11989	/* speaker */
11990	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11991	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11992	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11993	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11994	/* HP */
11995	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11996	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11997	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11998	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11999	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12000	/* internal mic */
12001	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12002	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12003	/* ADC, choose mic */
12004	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12005	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12006	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12007	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12008	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12009	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12010	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12011	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12012	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12013	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
12014	{}
12015};
12016
12017/* mute/unmute internal speaker according to the hp jack and mute state */
12018static void alc262_ultra_automute(struct hda_codec *codec)
12019{
12020	struct alc_spec *spec = codec->spec;
12021	unsigned int mute;
12022
12023	mute = 0;
12024	/* auto-mute only when HP is used as HP */
12025	if (!spec->cur_mux[0]) {
12026		spec->jack_present = snd_hda_jack_detect(codec, 0x15);
12027		if (spec->jack_present)
12028			mute = HDA_AMP_MUTE;
12029	}
12030	/* mute/unmute internal speaker */
12031	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
12032				 HDA_AMP_MUTE, mute);
12033	/* mute/unmute HP */
12034	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12035				 HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
12036}
12037
12038/* unsolicited event for HP jack sensing */
12039static void alc262_ultra_unsol_event(struct hda_codec *codec,
12040				       unsigned int res)
12041{
12042	if ((res >> 26) != ALC880_HP_EVENT)
12043		return;
12044	alc262_ultra_automute(codec);
12045}
12046
12047static struct hda_input_mux alc262_ultra_capture_source = {
12048	.num_items = 2,
12049	.items = {
12050		{ "Mic", 0x1 },
12051		{ "Headphone", 0x7 },
12052	},
12053};
12054
12055static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
12056				     struct snd_ctl_elem_value *ucontrol)
12057{
12058	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12059	struct alc_spec *spec = codec->spec;
12060	int ret;
12061
12062	ret = alc_mux_enum_put(kcontrol, ucontrol);
12063	if (!ret)
12064		return 0;
12065	/* reprogram the HP pin as mic or HP according to the input source */
12066	snd_hda_codec_write_cache(codec, 0x15, 0,
12067				  AC_VERB_SET_PIN_WIDGET_CONTROL,
12068				  spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
12069	alc262_ultra_automute(codec); /* mute/unmute HP */
12070	return ret;
12071}
12072
12073static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
12074	HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
12075	HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
12076	{
12077		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12078		.name = "Capture Source",
12079		.info = alc_mux_enum_info,
12080		.get = alc_mux_enum_get,
12081		.put = alc262_ultra_mux_enum_put,
12082	},
12083	{
12084		.iface = NID_MAPPING,
12085		.name = "Capture Source",
12086		.private_value = 0x15,
12087	},
12088	{ } /* end */
12089};
12090
12091/* We use two mixers depending on the output pin; 0x16 is a mono output
12092 * and thus it's bound with a different mixer.
12093 * This function returns which mixer amp should be used.
12094 */
12095static int alc262_check_volbit(hda_nid_t nid)
12096{
12097	if (!nid)
12098		return 0;
12099	else if (nid == 0x16)
12100		return 2;
12101	else
12102		return 1;
12103}
12104
12105static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
12106				  const char *pfx, int *vbits, int idx)
12107{
12108	unsigned long val;
12109	int vbit;
12110
12111	vbit = alc262_check_volbit(nid);
12112	if (!vbit)
12113		return 0;
12114	if (*vbits & vbit) /* a volume control for this mixer already there */
12115		return 0;
12116	*vbits |= vbit;
12117	if (vbit == 2)
12118		val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
12119	else
12120		val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
12121	return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
12122}
12123
12124static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
12125				 const char *pfx, int idx)
12126{
12127	unsigned long val;
12128
12129	if (!nid)
12130		return 0;
12131	if (nid == 0x16)
12132		val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
12133	else
12134		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
12135	return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
12136}
12137
12138/* add playback controls from the parsed DAC table */
12139static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
12140					     const struct auto_pin_cfg *cfg)
12141{
12142	const char *pfx;
12143	int vbits;
12144	int i, err;
12145
12146	spec->multiout.num_dacs = 1;	/* only use one dac */
12147	spec->multiout.dac_nids = spec->private_dac_nids;
12148	spec->multiout.dac_nids[0] = 2;
12149
12150	pfx = alc_get_line_out_pfx(cfg, true);
12151	if (!pfx)
12152		pfx = "Front";
12153	for (i = 0; i < 2; i++) {
12154		err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
12155		if (err < 0)
12156			return err;
12157		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12158			err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
12159						    "Speaker", i);
12160			if (err < 0)
12161				return err;
12162		}
12163		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12164			err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
12165						    "Headphone", i);
12166			if (err < 0)
12167				return err;
12168		}
12169	}
12170
12171	vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
12172		alc262_check_volbit(cfg->speaker_pins[0]) |
12173		alc262_check_volbit(cfg->hp_pins[0]);
12174	if (vbits == 1 || vbits == 2)
12175		pfx = "Master"; /* only one mixer is used */
12176	vbits = 0;
12177	for (i = 0; i < 2; i++) {
12178		err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
12179					     &vbits, i);
12180		if (err < 0)
12181			return err;
12182		if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
12183			err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
12184						     "Speaker", &vbits, i);
12185			if (err < 0)
12186				return err;
12187		}
12188		if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
12189			err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
12190						     "Headphone", &vbits, i);
12191			if (err < 0)
12192				return err;
12193		}
12194	}
12195	return 0;
12196}
12197
12198#define alc262_auto_create_input_ctls \
12199	alc882_auto_create_input_ctls
12200
12201/*
12202 * generic initialization of ADC, input mixers and output mixers
12203 */
12204static struct hda_verb alc262_volume_init_verbs[] = {
12205	/*
12206	 * Unmute ADC0-2 and set the default input to mic-in
12207	 */
12208	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12209	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12210	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12211	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12212	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12213	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12214
12215	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12216	 * mixer widget
12217	 * Note: PASD motherboards uses the Line In 2 as the input for
12218	 * front panel mic (mic 2)
12219	 */
12220	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12221	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12222	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12223	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12224	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12225	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12226
12227	/*
12228	 * Set up output mixers (0x0c - 0x0f)
12229	 */
12230	/* set vol=0 to output mixers */
12231	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12232	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12233	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12234
12235	/* set up input amps for analog loopback */
12236	/* Amp Indices: DAC = 0, mixer = 1 */
12237	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12238	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12239	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12240	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12241	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12242	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12243
12244	/* FIXME: use matrix-type input source selection */
12245	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12246	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12247	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12248	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12249	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12250	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12251	/* Input mixer2 */
12252	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12253	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12254	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12255	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12256	/* Input mixer3 */
12257	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12258	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12259	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12260	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12261
12262	{ }
12263};
12264
12265static struct hda_verb alc262_HP_BPC_init_verbs[] = {
12266	/*
12267	 * Unmute ADC0-2 and set the default input to mic-in
12268	 */
12269	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12270	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12271	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12272	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12273	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12274	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12275
12276	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12277	 * mixer widget
12278	 * Note: PASD motherboards uses the Line In 2 as the input for
12279	 * front panel mic (mic 2)
12280	 */
12281	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12282	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12283	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12284	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12285	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12286	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12287	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12288        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12289
12290	/*
12291	 * Set up output mixers (0x0c - 0x0e)
12292	 */
12293	/* set vol=0 to output mixers */
12294	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12295	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12296	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12297
12298	/* set up input amps for analog loopback */
12299	/* Amp Indices: DAC = 0, mixer = 1 */
12300	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12301	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12302	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12303	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12304	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12305	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12306
12307	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12308	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12309	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12310
12311	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12312	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12313
12314	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12315	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12316
12317	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12318	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12319        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12320	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12321	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12322
12323	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12324	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12325        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12326	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12327	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12328	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12329
12330
12331	/* FIXME: use matrix-type input source selection */
12332	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12333	/* Input mixer1: only unmute Mic */
12334	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12335	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12336	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12337	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12338	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12339	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12340	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12341	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12342	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12343	/* Input mixer2 */
12344	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12345	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12346	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12347	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12348	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12349	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12350	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12351	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12352	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12353	/* Input mixer3 */
12354	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12355	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12356	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12357	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12358	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12359	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12360	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12361	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12362	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12363
12364	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12365
12366	{ }
12367};
12368
12369static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12370	/*
12371	 * Unmute ADC0-2 and set the default input to mic-in
12372	 */
12373	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12374	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12375	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12376	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12377	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12378	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12379
12380	/* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12381	 * mixer widget
12382	 * Note: PASD motherboards uses the Line In 2 as the input for front
12383	 * panel mic (mic 2)
12384	 */
12385	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12386	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12387	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12388	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12389	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12390	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12391	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12392	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12393	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12394	/*
12395	 * Set up output mixers (0x0c - 0x0e)
12396	 */
12397	/* set vol=0 to output mixers */
12398	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12399	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12400	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12401
12402	/* set up input amps for analog loopback */
12403	/* Amp Indices: DAC = 0, mixer = 1 */
12404	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12405	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12406	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12407	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12408	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12409	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12410
12411
12412	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP */
12413	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Mono */
12414	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* rear MIC */
12415	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* Line in */
12416	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
12417	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Line out */
12418	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },	/* CD in */
12419
12420	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12421	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12422
12423	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12424	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12425
12426	/* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12427	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12428	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12429	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12430	{0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12431	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12432
12433	/* FIXME: use matrix-type input source selection */
12434	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12435	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12436	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12437	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12438	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12439	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12440	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12441        /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12442	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12443	/* Input mixer2 */
12444	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12445	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12446	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12447	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12448	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12449        /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12450	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12451	/* Input mixer3 */
12452	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12453	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12454	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12455	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12456	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12457        /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12458	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12459
12460	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12461
12462	{ }
12463};
12464
12465static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12466
12467	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },	/* Front Speaker */
12468	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12469	{0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12470
12471	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* MIC jack */
12472	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },	/* Front MIC */
12473	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12474	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12475
12476	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },	/* HP  jack */
12477	{0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12478	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12479	{}
12480};
12481
12482/*
12483 * Pin config fixes
12484 */
12485enum {
12486	PINFIX_FSC_H270,
12487};
12488
12489static const struct alc_fixup alc262_fixups[] = {
12490	[PINFIX_FSC_H270] = {
12491		.type = ALC_FIXUP_PINS,
12492		.v.pins = (const struct alc_pincfg[]) {
12493			{ 0x14, 0x99130110 }, /* speaker */
12494			{ 0x15, 0x0221142f }, /* front HP */
12495			{ 0x1b, 0x0121141f }, /* rear HP */
12496			{ }
12497		}
12498	},
12499};
12500
12501static struct snd_pci_quirk alc262_fixup_tbl[] = {
12502	SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270),
12503	{}
12504};
12505
12506
12507#ifdef CONFIG_SND_HDA_POWER_SAVE
12508#define alc262_loopbacks	alc880_loopbacks
12509#endif
12510
12511/* pcm configuration: identical with ALC880 */
12512#define alc262_pcm_analog_playback	alc880_pcm_analog_playback
12513#define alc262_pcm_analog_capture	alc880_pcm_analog_capture
12514#define alc262_pcm_digital_playback	alc880_pcm_digital_playback
12515#define alc262_pcm_digital_capture	alc880_pcm_digital_capture
12516
12517/*
12518 * BIOS auto configuration
12519 */
12520static int alc262_parse_auto_config(struct hda_codec *codec)
12521{
12522	struct alc_spec *spec = codec->spec;
12523	int err;
12524	static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12525
12526	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12527					   alc262_ignore);
12528	if (err < 0)
12529		return err;
12530	if (!spec->autocfg.line_outs) {
12531		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12532			spec->multiout.max_channels = 2;
12533			spec->no_analog = 1;
12534			goto dig_only;
12535		}
12536		return 0; /* can't find valid BIOS pin config */
12537	}
12538	err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12539	if (err < 0)
12540		return err;
12541	err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12542	if (err < 0)
12543		return err;
12544
12545	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12546
12547 dig_only:
12548	alc_auto_parse_digital(codec);
12549
12550	if (spec->kctls.list)
12551		add_mixer(spec, spec->kctls.list);
12552
12553	add_verb(spec, alc262_volume_init_verbs);
12554	spec->num_mux_defs = 1;
12555	spec->input_mux = &spec->private_imux[0];
12556
12557	err = alc_auto_add_mic_boost(codec);
12558	if (err < 0)
12559		return err;
12560
12561	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12562
12563	return 1;
12564}
12565
12566#define alc262_auto_init_multi_out	alc882_auto_init_multi_out
12567#define alc262_auto_init_hp_out		alc882_auto_init_hp_out
12568#define alc262_auto_init_analog_input	alc882_auto_init_analog_input
12569#define alc262_auto_init_input_src	alc882_auto_init_input_src
12570
12571
12572/* init callback for auto-configuration model -- overriding the default init */
12573static void alc262_auto_init(struct hda_codec *codec)
12574{
12575	struct alc_spec *spec = codec->spec;
12576	alc262_auto_init_multi_out(codec);
12577	alc262_auto_init_hp_out(codec);
12578	alc262_auto_init_analog_input(codec);
12579	alc262_auto_init_input_src(codec);
12580	alc_auto_init_digital(codec);
12581	if (spec->unsol_event)
12582		alc_inithook(codec);
12583}
12584
12585/*
12586 * configuration and preset
12587 */
12588static const char * const alc262_models[ALC262_MODEL_LAST] = {
12589	[ALC262_BASIC]		= "basic",
12590	[ALC262_HIPPO]		= "hippo",
12591	[ALC262_HIPPO_1]	= "hippo_1",
12592	[ALC262_FUJITSU]	= "fujitsu",
12593	[ALC262_HP_BPC]		= "hp-bpc",
12594	[ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12595	[ALC262_HP_TC_T5735]	= "hp-tc-t5735",
12596	[ALC262_HP_RP5700]	= "hp-rp5700",
12597	[ALC262_BENQ_ED8]	= "benq",
12598	[ALC262_BENQ_T31]	= "benq-t31",
12599	[ALC262_SONY_ASSAMD]	= "sony-assamd",
12600	[ALC262_TOSHIBA_S06]	= "toshiba-s06",
12601	[ALC262_TOSHIBA_RX1]	= "toshiba-rx1",
12602	[ALC262_ULTRA]		= "ultra",
12603	[ALC262_LENOVO_3000]	= "lenovo-3000",
12604	[ALC262_NEC]		= "nec",
12605	[ALC262_TYAN]		= "tyan",
12606	[ALC262_AUTO]		= "auto",
12607};
12608
12609static struct snd_pci_quirk alc262_cfg_tbl[] = {
12610	SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12611	SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12612	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12613			   ALC262_HP_BPC),
12614	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12615			   ALC262_HP_BPC),
12616	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1500, "HP z series",
12617			   ALC262_HP_BPC),
12618	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12619			   ALC262_HP_BPC),
12620	SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12621	SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12622	SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12623	SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12624	SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12625	SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12626	SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12627	SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12628	SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12629	SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12630	SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12631	SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12632		      ALC262_HP_TC_T5735),
12633	SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12634	SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12635	SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12636	SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12637	SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12638	SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12639	SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12640	SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12641#if 0 /* disable the quirk since model=auto works better in recent versions */
12642	SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12643			   ALC262_SONY_ASSAMD),
12644#endif
12645	SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12646		      ALC262_TOSHIBA_RX1),
12647	SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12648	SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12649	SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12650	SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12651	SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12652			   ALC262_ULTRA),
12653	SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12654	SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12655	SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12656	SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12657	SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12658	{}
12659};
12660
12661static struct alc_config_preset alc262_presets[] = {
12662	[ALC262_BASIC] = {
12663		.mixers = { alc262_base_mixer },
12664		.init_verbs = { alc262_init_verbs },
12665		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12666		.dac_nids = alc262_dac_nids,
12667		.hp_nid = 0x03,
12668		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12669		.channel_mode = alc262_modes,
12670		.input_mux = &alc262_capture_source,
12671	},
12672	[ALC262_HIPPO] = {
12673		.mixers = { alc262_hippo_mixer },
12674		.init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12675		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12676		.dac_nids = alc262_dac_nids,
12677		.hp_nid = 0x03,
12678		.dig_out_nid = ALC262_DIGOUT_NID,
12679		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12680		.channel_mode = alc262_modes,
12681		.input_mux = &alc262_capture_source,
12682		.unsol_event = alc262_hippo_unsol_event,
12683		.setup = alc262_hippo_setup,
12684		.init_hook = alc262_hippo_automute,
12685	},
12686	[ALC262_HIPPO_1] = {
12687		.mixers = { alc262_hippo1_mixer },
12688		.init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12689		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12690		.dac_nids = alc262_dac_nids,
12691		.hp_nid = 0x02,
12692		.dig_out_nid = ALC262_DIGOUT_NID,
12693		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12694		.channel_mode = alc262_modes,
12695		.input_mux = &alc262_capture_source,
12696		.unsol_event = alc262_hippo_unsol_event,
12697		.setup = alc262_hippo1_setup,
12698		.init_hook = alc262_hippo_automute,
12699	},
12700	[ALC262_FUJITSU] = {
12701		.mixers = { alc262_fujitsu_mixer },
12702		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12703				alc262_fujitsu_unsol_verbs },
12704		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12705		.dac_nids = alc262_dac_nids,
12706		.hp_nid = 0x03,
12707		.dig_out_nid = ALC262_DIGOUT_NID,
12708		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12709		.channel_mode = alc262_modes,
12710		.input_mux = &alc262_fujitsu_capture_source,
12711		.unsol_event = alc262_fujitsu_unsol_event,
12712		.init_hook = alc262_fujitsu_init_hook,
12713	},
12714	[ALC262_HP_BPC] = {
12715		.mixers = { alc262_HP_BPC_mixer },
12716		.init_verbs = { alc262_HP_BPC_init_verbs },
12717		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12718		.dac_nids = alc262_dac_nids,
12719		.hp_nid = 0x03,
12720		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12721		.channel_mode = alc262_modes,
12722		.input_mux = &alc262_HP_capture_source,
12723		.unsol_event = alc262_hp_bpc_unsol_event,
12724		.init_hook = alc262_hp_bpc_automute,
12725	},
12726	[ALC262_HP_BPC_D7000_WF] = {
12727		.mixers = { alc262_HP_BPC_WildWest_mixer },
12728		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12729		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12730		.dac_nids = alc262_dac_nids,
12731		.hp_nid = 0x03,
12732		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12733		.channel_mode = alc262_modes,
12734		.input_mux = &alc262_HP_D7000_capture_source,
12735		.unsol_event = alc262_hp_wildwest_unsol_event,
12736		.init_hook = alc262_hp_wildwest_automute,
12737	},
12738	[ALC262_HP_BPC_D7000_WL] = {
12739		.mixers = { alc262_HP_BPC_WildWest_mixer,
12740			    alc262_HP_BPC_WildWest_option_mixer },
12741		.init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12742		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12743		.dac_nids = alc262_dac_nids,
12744		.hp_nid = 0x03,
12745		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12746		.channel_mode = alc262_modes,
12747		.input_mux = &alc262_HP_D7000_capture_source,
12748		.unsol_event = alc262_hp_wildwest_unsol_event,
12749		.init_hook = alc262_hp_wildwest_automute,
12750	},
12751	[ALC262_HP_TC_T5735] = {
12752		.mixers = { alc262_hp_t5735_mixer },
12753		.init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12754		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12755		.dac_nids = alc262_dac_nids,
12756		.hp_nid = 0x03,
12757		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12758		.channel_mode = alc262_modes,
12759		.input_mux = &alc262_capture_source,
12760		.unsol_event = alc_sku_unsol_event,
12761		.setup = alc262_hp_t5735_setup,
12762		.init_hook = alc_inithook,
12763	},
12764	[ALC262_HP_RP5700] = {
12765		.mixers = { alc262_hp_rp5700_mixer },
12766		.init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12767		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12768		.dac_nids = alc262_dac_nids,
12769		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12770		.channel_mode = alc262_modes,
12771		.input_mux = &alc262_hp_rp5700_capture_source,
12772        },
12773	[ALC262_BENQ_ED8] = {
12774		.mixers = { alc262_base_mixer },
12775		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12776		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12777		.dac_nids = alc262_dac_nids,
12778		.hp_nid = 0x03,
12779		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12780		.channel_mode = alc262_modes,
12781		.input_mux = &alc262_capture_source,
12782	},
12783	[ALC262_SONY_ASSAMD] = {
12784		.mixers = { alc262_sony_mixer },
12785		.init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12786		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12787		.dac_nids = alc262_dac_nids,
12788		.hp_nid = 0x02,
12789		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12790		.channel_mode = alc262_modes,
12791		.input_mux = &alc262_capture_source,
12792		.unsol_event = alc262_hippo_unsol_event,
12793		.setup = alc262_hippo_setup,
12794		.init_hook = alc262_hippo_automute,
12795	},
12796	[ALC262_BENQ_T31] = {
12797		.mixers = { alc262_benq_t31_mixer },
12798		.init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12799				alc_hp15_unsol_verbs },
12800		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12801		.dac_nids = alc262_dac_nids,
12802		.hp_nid = 0x03,
12803		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12804		.channel_mode = alc262_modes,
12805		.input_mux = &alc262_capture_source,
12806		.unsol_event = alc262_hippo_unsol_event,
12807		.setup = alc262_hippo_setup,
12808		.init_hook = alc262_hippo_automute,
12809	},
12810	[ALC262_ULTRA] = {
12811		.mixers = { alc262_ultra_mixer },
12812		.cap_mixer = alc262_ultra_capture_mixer,
12813		.init_verbs = { alc262_ultra_verbs },
12814		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12815		.dac_nids = alc262_dac_nids,
12816		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12817		.channel_mode = alc262_modes,
12818		.input_mux = &alc262_ultra_capture_source,
12819		.adc_nids = alc262_adc_nids, /* ADC0 */
12820		.capsrc_nids = alc262_capsrc_nids,
12821		.num_adc_nids = 1, /* single ADC */
12822		.unsol_event = alc262_ultra_unsol_event,
12823		.init_hook = alc262_ultra_automute,
12824	},
12825	[ALC262_LENOVO_3000] = {
12826		.mixers = { alc262_lenovo_3000_mixer },
12827		.init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12828				alc262_lenovo_3000_unsol_verbs,
12829				alc262_lenovo_3000_init_verbs },
12830		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12831		.dac_nids = alc262_dac_nids,
12832		.hp_nid = 0x03,
12833		.dig_out_nid = ALC262_DIGOUT_NID,
12834		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12835		.channel_mode = alc262_modes,
12836		.input_mux = &alc262_fujitsu_capture_source,
12837		.unsol_event = alc262_lenovo_3000_unsol_event,
12838	},
12839	[ALC262_NEC] = {
12840		.mixers = { alc262_nec_mixer },
12841		.init_verbs = { alc262_nec_verbs },
12842		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12843		.dac_nids = alc262_dac_nids,
12844		.hp_nid = 0x03,
12845		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12846		.channel_mode = alc262_modes,
12847		.input_mux = &alc262_capture_source,
12848	},
12849	[ALC262_TOSHIBA_S06] = {
12850		.mixers = { alc262_toshiba_s06_mixer },
12851		.init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12852							alc262_eapd_verbs },
12853		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12854		.capsrc_nids = alc262_dmic_capsrc_nids,
12855		.dac_nids = alc262_dac_nids,
12856		.adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12857		.num_adc_nids = 1, /* single ADC */
12858		.dig_out_nid = ALC262_DIGOUT_NID,
12859		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12860		.channel_mode = alc262_modes,
12861		.unsol_event = alc_sku_unsol_event,
12862		.setup = alc262_toshiba_s06_setup,
12863		.init_hook = alc_inithook,
12864	},
12865	[ALC262_TOSHIBA_RX1] = {
12866		.mixers = { alc262_toshiba_rx1_mixer },
12867		.init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12868		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12869		.dac_nids = alc262_dac_nids,
12870		.hp_nid = 0x03,
12871		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12872		.channel_mode = alc262_modes,
12873		.input_mux = &alc262_capture_source,
12874		.unsol_event = alc262_hippo_unsol_event,
12875		.setup = alc262_hippo_setup,
12876		.init_hook = alc262_hippo_automute,
12877	},
12878	[ALC262_TYAN] = {
12879		.mixers = { alc262_tyan_mixer },
12880		.init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12881		.num_dacs = ARRAY_SIZE(alc262_dac_nids),
12882		.dac_nids = alc262_dac_nids,
12883		.hp_nid = 0x02,
12884		.dig_out_nid = ALC262_DIGOUT_NID,
12885		.num_channel_mode = ARRAY_SIZE(alc262_modes),
12886		.channel_mode = alc262_modes,
12887		.input_mux = &alc262_capture_source,
12888		.unsol_event = alc_automute_amp_unsol_event,
12889		.setup = alc262_tyan_setup,
12890		.init_hook = alc_automute_amp,
12891	},
12892};
12893
12894static int patch_alc262(struct hda_codec *codec)
12895{
12896	struct alc_spec *spec;
12897	int board_config;
12898	int err;
12899
12900	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12901	if (spec == NULL)
12902		return -ENOMEM;
12903
12904	codec->spec = spec;
12905#if 0
12906	/* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12907	 * under-run
12908	 */
12909	{
12910	int tmp;
12911	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12912	tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12913	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12914	snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12915	}
12916#endif
12917	alc_auto_parse_customize_define(codec);
12918
12919	alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12920
12921	board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12922						  alc262_models,
12923						  alc262_cfg_tbl);
12924
12925	if (board_config < 0) {
12926		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12927		       codec->chip_name);
12928		board_config = ALC262_AUTO;
12929	}
12930
12931	if (board_config == ALC262_AUTO) {
12932		alc_pick_fixup(codec, NULL, alc262_fixup_tbl, alc262_fixups);
12933		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
12934	}
12935
12936	if (board_config == ALC262_AUTO) {
12937		/* automatic parse from the BIOS config */
12938		err = alc262_parse_auto_config(codec);
12939		if (err < 0) {
12940			alc_free(codec);
12941			return err;
12942		} else if (!err) {
12943			printk(KERN_INFO
12944			       "hda_codec: Cannot set up configuration "
12945			       "from BIOS.  Using base mode...\n");
12946			board_config = ALC262_BASIC;
12947		}
12948	}
12949
12950	if (!spec->no_analog && has_cdefine_beep(codec)) {
12951		err = snd_hda_attach_beep_device(codec, 0x1);
12952		if (err < 0) {
12953			alc_free(codec);
12954			return err;
12955		}
12956	}
12957
12958	if (board_config != ALC262_AUTO)
12959		setup_preset(codec, &alc262_presets[board_config]);
12960
12961	spec->stream_analog_playback = &alc262_pcm_analog_playback;
12962	spec->stream_analog_capture = &alc262_pcm_analog_capture;
12963
12964	spec->stream_digital_playback = &alc262_pcm_digital_playback;
12965	spec->stream_digital_capture = &alc262_pcm_digital_capture;
12966
12967	if (!spec->adc_nids && spec->input_mux) {
12968		int i;
12969		/* check whether the digital-mic has to be supported */
12970		for (i = 0; i < spec->input_mux->num_items; i++) {
12971			if (spec->input_mux->items[i].index >= 9)
12972				break;
12973		}
12974		if (i < spec->input_mux->num_items) {
12975			/* use only ADC0 */
12976			spec->adc_nids = alc262_dmic_adc_nids;
12977			spec->num_adc_nids = 1;
12978			spec->capsrc_nids = alc262_dmic_capsrc_nids;
12979		} else {
12980			/* all analog inputs */
12981			/* check whether NID 0x07 is valid */
12982			unsigned int wcap = get_wcaps(codec, 0x07);
12983
12984			/* get type */
12985			wcap = get_wcaps_type(wcap);
12986			if (wcap != AC_WID_AUD_IN) {
12987				spec->adc_nids = alc262_adc_nids_alt;
12988				spec->num_adc_nids =
12989					ARRAY_SIZE(alc262_adc_nids_alt);
12990				spec->capsrc_nids = alc262_capsrc_nids_alt;
12991			} else {
12992				spec->adc_nids = alc262_adc_nids;
12993				spec->num_adc_nids =
12994					ARRAY_SIZE(alc262_adc_nids);
12995				spec->capsrc_nids = alc262_capsrc_nids;
12996			}
12997		}
12998	}
12999	if (!spec->cap_mixer && !spec->no_analog)
13000		set_capture_mixer(codec);
13001	if (!spec->no_analog && has_cdefine_beep(codec))
13002		set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
13003
13004	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
13005
13006	spec->vmaster_nid = 0x0c;
13007
13008	codec->patch_ops = alc_patch_ops;
13009	if (board_config == ALC262_AUTO)
13010		spec->init_hook = alc262_auto_init;
13011
13012	alc_init_jacks(codec);
13013#ifdef CONFIG_SND_HDA_POWER_SAVE
13014	if (!spec->loopback.amplist)
13015		spec->loopback.amplist = alc262_loopbacks;
13016#endif
13017
13018	return 0;
13019}
13020
13021/*
13022 *  ALC268 channel source setting (2 channel)
13023 */
13024#define ALC268_DIGOUT_NID	ALC880_DIGOUT_NID
13025#define alc268_modes		alc260_modes
13026
13027static hda_nid_t alc268_dac_nids[2] = {
13028	/* front, hp */
13029	0x02, 0x03
13030};
13031
13032static hda_nid_t alc268_adc_nids[2] = {
13033	/* ADC0-1 */
13034	0x08, 0x07
13035};
13036
13037static hda_nid_t alc268_adc_nids_alt[1] = {
13038	/* ADC0 */
13039	0x08
13040};
13041
13042static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
13043
13044static struct snd_kcontrol_new alc268_base_mixer[] = {
13045	/* output mixer control */
13046	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13047	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13048	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13049	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13050	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13051	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13052	HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13053	{ }
13054};
13055
13056static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
13057	/* output mixer control */
13058	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13059	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13060	ALC262_HIPPO_MASTER_SWITCH,
13061	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13062	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
13063	HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13064	{ }
13065};
13066
13067/* bind Beep switches of both NID 0x0f and 0x10 */
13068static struct hda_bind_ctls alc268_bind_beep_sw = {
13069	.ops = &snd_hda_bind_sw,
13070	.values = {
13071		HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
13072		HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
13073		0
13074	},
13075};
13076
13077static struct snd_kcontrol_new alc268_beep_mixer[] = {
13078	HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
13079	HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
13080	{ }
13081};
13082
13083static struct hda_verb alc268_eapd_verbs[] = {
13084	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13085	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13086	{ }
13087};
13088
13089/* Toshiba specific */
13090static struct hda_verb alc268_toshiba_verbs[] = {
13091	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13092	{ } /* end */
13093};
13094
13095/* Acer specific */
13096/* bind volumes of both NID 0x02 and 0x03 */
13097static struct hda_bind_ctls alc268_acer_bind_master_vol = {
13098	.ops = &snd_hda_bind_vol,
13099	.values = {
13100		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
13101		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
13102		0
13103	},
13104};
13105
13106/* mute/unmute internal speaker according to the hp jack and mute state */
13107static void alc268_acer_automute(struct hda_codec *codec, int force)
13108{
13109	struct alc_spec *spec = codec->spec;
13110	unsigned int mute;
13111
13112	if (force || !spec->sense_updated) {
13113		spec->jack_present = snd_hda_jack_detect(codec, 0x14);
13114		spec->sense_updated = 1;
13115	}
13116	if (spec->jack_present)
13117		mute = HDA_AMP_MUTE; /* mute internal speaker */
13118	else /* unmute internal speaker if necessary */
13119		mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
13120	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
13121				 HDA_AMP_MUTE, mute);
13122}
13123
13124
13125/* bind hp and internal speaker mute (with plug check) */
13126static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
13127				     struct snd_ctl_elem_value *ucontrol)
13128{
13129	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
13130	long *valp = ucontrol->value.integer.value;
13131	int change;
13132
13133	change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
13134	if (change)
13135		alc268_acer_automute(codec, 0);
13136	return change;
13137}
13138
13139static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
13140	/* output mixer control */
13141	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13142	{
13143		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13144		.name = "Master Playback Switch",
13145		.subdevice = HDA_SUBDEV_AMP_FLAG,
13146		.info = snd_hda_mixer_amp_switch_info,
13147		.get = snd_hda_mixer_amp_switch_get,
13148		.put = alc268_acer_master_sw_put,
13149		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13150	},
13151	HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
13152	{ }
13153};
13154
13155static struct snd_kcontrol_new alc268_acer_mixer[] = {
13156	/* output mixer control */
13157	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13158	{
13159		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13160		.name = "Master Playback Switch",
13161		.subdevice = HDA_SUBDEV_AMP_FLAG,
13162		.info = snd_hda_mixer_amp_switch_info,
13163		.get = snd_hda_mixer_amp_switch_get,
13164		.put = alc268_acer_master_sw_put,
13165		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13166	},
13167	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13168	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13169	HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13170	{ }
13171};
13172
13173static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
13174	/* output mixer control */
13175	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13176	{
13177		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13178		.name = "Master Playback Switch",
13179		.subdevice = HDA_SUBDEV_AMP_FLAG,
13180		.info = snd_hda_mixer_amp_switch_info,
13181		.get = snd_hda_mixer_amp_switch_get,
13182		.put = alc268_acer_master_sw_put,
13183		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13184	},
13185	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13186	HDA_CODEC_VOLUME("Line In Boost Volume", 0x1a, 0, HDA_INPUT),
13187	{ }
13188};
13189
13190static struct hda_verb alc268_acer_aspire_one_verbs[] = {
13191	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13192	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13193	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13194	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13195	{0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
13196	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
13197	{ }
13198};
13199
13200static struct hda_verb alc268_acer_verbs[] = {
13201	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
13202	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13203	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13204	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13205	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13206	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13207	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13208	{ }
13209};
13210
13211/* unsolicited event for HP jack sensing */
13212#define alc268_toshiba_unsol_event	alc262_hippo_unsol_event
13213#define alc268_toshiba_setup		alc262_hippo_setup
13214#define alc268_toshiba_automute		alc262_hippo_automute
13215
13216static void alc268_acer_unsol_event(struct hda_codec *codec,
13217				       unsigned int res)
13218{
13219	if ((res >> 26) != ALC880_HP_EVENT)
13220		return;
13221	alc268_acer_automute(codec, 1);
13222}
13223
13224static void alc268_acer_init_hook(struct hda_codec *codec)
13225{
13226	alc268_acer_automute(codec, 1);
13227}
13228
13229/* toggle speaker-output according to the hp-jack state */
13230static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
13231{
13232	unsigned int present;
13233	unsigned char bits;
13234
13235	present = snd_hda_jack_detect(codec, 0x15);
13236	bits = present ? HDA_AMP_MUTE : 0;
13237	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
13238				 HDA_AMP_MUTE, bits);
13239	snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
13240				 HDA_AMP_MUTE, bits);
13241}
13242
13243static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
13244				    unsigned int res)
13245{
13246	switch (res >> 26) {
13247	case ALC880_HP_EVENT:
13248		alc268_aspire_one_speaker_automute(codec);
13249		break;
13250	case ALC880_MIC_EVENT:
13251		alc_mic_automute(codec);
13252		break;
13253	}
13254}
13255
13256static void alc268_acer_lc_setup(struct hda_codec *codec)
13257{
13258	struct alc_spec *spec = codec->spec;
13259	spec->ext_mic.pin = 0x18;
13260	spec->ext_mic.mux_idx = 0;
13261	spec->int_mic.pin = 0x12;
13262	spec->int_mic.mux_idx = 6;
13263	spec->auto_mic = 1;
13264}
13265
13266static void alc268_acer_lc_init_hook(struct hda_codec *codec)
13267{
13268	alc268_aspire_one_speaker_automute(codec);
13269	alc_mic_automute(codec);
13270}
13271
13272static struct snd_kcontrol_new alc268_dell_mixer[] = {
13273	/* output mixer control */
13274	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13275	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13276	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13277	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13278	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13279	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13280	{ }
13281};
13282
13283static struct hda_verb alc268_dell_verbs[] = {
13284	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13285	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13286	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13287	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13288	{ }
13289};
13290
13291/* mute/unmute internal speaker according to the hp jack and mute state */
13292static void alc268_dell_setup(struct hda_codec *codec)
13293{
13294	struct alc_spec *spec = codec->spec;
13295
13296	spec->autocfg.hp_pins[0] = 0x15;
13297	spec->autocfg.speaker_pins[0] = 0x14;
13298	spec->ext_mic.pin = 0x18;
13299	spec->ext_mic.mux_idx = 0;
13300	spec->int_mic.pin = 0x19;
13301	spec->int_mic.mux_idx = 1;
13302	spec->auto_mic = 1;
13303}
13304
13305static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
13306	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
13307	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13308	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13309	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13310	HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13311	HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13312	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
13313	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
13314	{ }
13315};
13316
13317static struct hda_verb alc267_quanta_il1_verbs[] = {
13318	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13319	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13320	{ }
13321};
13322
13323static void alc267_quanta_il1_setup(struct hda_codec *codec)
13324{
13325	struct alc_spec *spec = codec->spec;
13326	spec->autocfg.hp_pins[0] = 0x15;
13327	spec->autocfg.speaker_pins[0] = 0x14;
13328	spec->ext_mic.pin = 0x18;
13329	spec->ext_mic.mux_idx = 0;
13330	spec->int_mic.pin = 0x19;
13331	spec->int_mic.mux_idx = 1;
13332	spec->auto_mic = 1;
13333}
13334
13335/*
13336 * generic initialization of ADC, input mixers and output mixers
13337 */
13338static struct hda_verb alc268_base_init_verbs[] = {
13339	/* Unmute DAC0-1 and set vol = 0 */
13340	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13341	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13342
13343	/*
13344	 * Set up output mixers (0x0c - 0x0e)
13345	 */
13346	/* set vol=0 to output mixers */
13347	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13348        {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13349
13350	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13351	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13352
13353	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13354	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13355	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13356	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13357	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13358	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13359	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13360	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13361
13362	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13363	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13364	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13365	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13366	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13367
13368	/* set PCBEEP vol = 0, mute connections */
13369	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13370	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13371	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13372
13373	/* Unmute Selector 23h,24h and set the default input to mic-in */
13374
13375	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13376	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13377	{0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13378	{0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13379
13380	{ }
13381};
13382
13383/*
13384 * generic initialization of ADC, input mixers and output mixers
13385 */
13386static struct hda_verb alc268_volume_init_verbs[] = {
13387	/* set output DAC */
13388	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13389	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13390
13391	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13392	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13393	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13394	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13395	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13396
13397	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13398	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13399	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13400
13401	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13402	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13403
13404	/* set PCBEEP vol = 0, mute connections */
13405	{0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13406	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13407	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13408
13409	{ }
13410};
13411
13412static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13413	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13414	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13415	{ } /* end */
13416};
13417
13418static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13419	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13420	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13421	_DEFINE_CAPSRC(1),
13422	{ } /* end */
13423};
13424
13425static struct snd_kcontrol_new alc268_capture_mixer[] = {
13426	HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13427	HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13428	HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13429	HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13430	_DEFINE_CAPSRC(2),
13431	{ } /* end */
13432};
13433
13434static struct hda_input_mux alc268_capture_source = {
13435	.num_items = 4,
13436	.items = {
13437		{ "Mic", 0x0 },
13438		{ "Front Mic", 0x1 },
13439		{ "Line", 0x2 },
13440		{ "CD", 0x3 },
13441	},
13442};
13443
13444static struct hda_input_mux alc268_acer_capture_source = {
13445	.num_items = 3,
13446	.items = {
13447		{ "Mic", 0x0 },
13448		{ "Internal Mic", 0x1 },
13449		{ "Line", 0x2 },
13450	},
13451};
13452
13453static struct hda_input_mux alc268_acer_dmic_capture_source = {
13454	.num_items = 3,
13455	.items = {
13456		{ "Mic", 0x0 },
13457		{ "Internal Mic", 0x6 },
13458		{ "Line", 0x2 },
13459	},
13460};
13461
13462#ifdef CONFIG_SND_DEBUG
13463static struct snd_kcontrol_new alc268_test_mixer[] = {
13464	/* Volume widgets */
13465	HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13466	HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13467	HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13468	HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13469	HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13470	HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13471	HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13472	HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13473	HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13474	HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13475	HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13476	HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13477	HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13478	/* The below appears problematic on some hardwares */
13479	/*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13480	HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13481	HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13482	HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13483	HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13484
13485	/* Modes for retasking pin widgets */
13486	ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13487	ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13488	ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13489	ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13490
13491	/* Controls for GPIO pins, assuming they are configured as outputs */
13492	ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13493	ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13494	ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13495	ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13496
13497	/* Switches to allow the digital SPDIF output pin to be enabled.
13498	 * The ALC268 does not have an SPDIF input.
13499	 */
13500	ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13501
13502	/* A switch allowing EAPD to be enabled.  Some laptops seem to use
13503	 * this output to turn on an external amplifier.
13504	 */
13505	ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13506	ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13507
13508	{ } /* end */
13509};
13510#endif
13511
13512/* create input playback/capture controls for the given pin */
13513static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13514				    const char *ctlname, int idx)
13515{
13516	hda_nid_t dac;
13517	int err;
13518
13519	switch (nid) {
13520	case 0x14:
13521	case 0x16:
13522		dac = 0x02;
13523		break;
13524	case 0x15:
13525	case 0x1a: /* ALC259/269 only */
13526	case 0x1b: /* ALC259/269 only */
13527	case 0x21: /* ALC269vb has this pin, too */
13528		dac = 0x03;
13529		break;
13530	default:
13531		snd_printd(KERN_WARNING "hda_codec: "
13532			   "ignoring pin 0x%x as unknown\n", nid);
13533		return 0;
13534	}
13535	if (spec->multiout.dac_nids[0] != dac &&
13536	    spec->multiout.dac_nids[1] != dac) {
13537		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13538				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13539						      HDA_OUTPUT));
13540		if (err < 0)
13541			return err;
13542		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13543	}
13544
13545	if (nid != 0x16)
13546		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13547			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13548	else /* mono */
13549		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13550			  HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13551	if (err < 0)
13552		return err;
13553	return 0;
13554}
13555
13556/* add playback controls from the parsed DAC table */
13557static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13558					     const struct auto_pin_cfg *cfg)
13559{
13560	hda_nid_t nid;
13561	int err;
13562
13563	spec->multiout.dac_nids = spec->private_dac_nids;
13564
13565	nid = cfg->line_out_pins[0];
13566	if (nid) {
13567		const char *name;
13568		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13569			name = "Speaker";
13570		else
13571			name = "Front";
13572		err = alc268_new_analog_output(spec, nid, name, 0);
13573		if (err < 0)
13574			return err;
13575	}
13576
13577	nid = cfg->speaker_pins[0];
13578	if (nid == 0x1d) {
13579		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13580				  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13581		if (err < 0)
13582			return err;
13583	} else if (nid) {
13584		err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13585		if (err < 0)
13586			return err;
13587	}
13588	nid = cfg->hp_pins[0];
13589	if (nid) {
13590		err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13591		if (err < 0)
13592			return err;
13593	}
13594
13595	nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13596	if (nid == 0x16) {
13597		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13598				  HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13599		if (err < 0)
13600			return err;
13601	}
13602	return 0;
13603}
13604
13605/* create playback/capture controls for input pins */
13606static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13607						const struct auto_pin_cfg *cfg)
13608{
13609	return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13610}
13611
13612static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13613					      hda_nid_t nid, int pin_type)
13614{
13615	int idx;
13616
13617	alc_set_pin_output(codec, nid, pin_type);
13618	if (nid == 0x14 || nid == 0x16)
13619		idx = 0;
13620	else
13621		idx = 1;
13622	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13623}
13624
13625static void alc268_auto_init_multi_out(struct hda_codec *codec)
13626{
13627	struct alc_spec *spec = codec->spec;
13628	int i;
13629
13630	for (i = 0; i < spec->autocfg.line_outs; i++) {
13631		hda_nid_t nid = spec->autocfg.line_out_pins[i];
13632		int pin_type = get_pin_type(spec->autocfg.line_out_type);
13633		alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13634	}
13635}
13636
13637static void alc268_auto_init_hp_out(struct hda_codec *codec)
13638{
13639	struct alc_spec *spec = codec->spec;
13640	hda_nid_t pin;
13641	int i;
13642
13643	for (i = 0; i < spec->autocfg.hp_outs; i++) {
13644		pin = spec->autocfg.hp_pins[i];
13645		alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13646	}
13647	for (i = 0; i < spec->autocfg.speaker_outs; i++) {
13648		pin = spec->autocfg.speaker_pins[i];
13649		alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13650	}
13651	if (spec->autocfg.mono_out_pin)
13652		snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0,
13653				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13654}
13655
13656static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13657{
13658	struct alc_spec *spec = codec->spec;
13659	hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13660	hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13661	hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13662	unsigned int	dac_vol1, dac_vol2;
13663
13664	if (line_nid == 0x1d || speaker_nid == 0x1d) {
13665		snd_hda_codec_write(codec, speaker_nid, 0,
13666				    AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13667		/* mute mixer inputs from 0x1d */
13668		snd_hda_codec_write(codec, 0x0f, 0,
13669				    AC_VERB_SET_AMP_GAIN_MUTE,
13670				    AMP_IN_UNMUTE(1));
13671		snd_hda_codec_write(codec, 0x10, 0,
13672				    AC_VERB_SET_AMP_GAIN_MUTE,
13673				    AMP_IN_UNMUTE(1));
13674	} else {
13675		/* unmute mixer inputs from 0x1d */
13676		snd_hda_codec_write(codec, 0x0f, 0,
13677				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13678		snd_hda_codec_write(codec, 0x10, 0,
13679				    AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13680	}
13681
13682	dac_vol1 = dac_vol2 = 0xb000 | 0x40;	/* set max volume  */
13683	if (line_nid == 0x14)
13684		dac_vol2 = AMP_OUT_ZERO;
13685	else if (line_nid == 0x15)
13686		dac_vol1 = AMP_OUT_ZERO;
13687	if (hp_nid == 0x14)
13688		dac_vol2 = AMP_OUT_ZERO;
13689	else if (hp_nid == 0x15)
13690		dac_vol1 = AMP_OUT_ZERO;
13691	if (line_nid != 0x16 || hp_nid != 0x16 ||
13692	    spec->autocfg.line_out_pins[1] != 0x16 ||
13693	    spec->autocfg.line_out_pins[2] != 0x16)
13694		dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13695
13696	snd_hda_codec_write(codec, 0x02, 0,
13697			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13698	snd_hda_codec_write(codec, 0x03, 0,
13699			    AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13700}
13701
13702/* pcm configuration: identical with ALC880 */
13703#define alc268_pcm_analog_playback	alc880_pcm_analog_playback
13704#define alc268_pcm_analog_capture	alc880_pcm_analog_capture
13705#define alc268_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
13706#define alc268_pcm_digital_playback	alc880_pcm_digital_playback
13707
13708/*
13709 * BIOS auto configuration
13710 */
13711static int alc268_parse_auto_config(struct hda_codec *codec)
13712{
13713	struct alc_spec *spec = codec->spec;
13714	int err;
13715	static hda_nid_t alc268_ignore[] = { 0 };
13716
13717	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13718					   alc268_ignore);
13719	if (err < 0)
13720		return err;
13721	if (!spec->autocfg.line_outs) {
13722		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13723			spec->multiout.max_channels = 2;
13724			spec->no_analog = 1;
13725			goto dig_only;
13726		}
13727		return 0; /* can't find valid BIOS pin config */
13728	}
13729	err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13730	if (err < 0)
13731		return err;
13732	err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13733	if (err < 0)
13734		return err;
13735
13736	spec->multiout.max_channels = 2;
13737
13738 dig_only:
13739	/* digital only support output */
13740	alc_auto_parse_digital(codec);
13741	if (spec->kctls.list)
13742		add_mixer(spec, spec->kctls.list);
13743
13744	if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13745		add_mixer(spec, alc268_beep_mixer);
13746
13747	add_verb(spec, alc268_volume_init_verbs);
13748	spec->num_mux_defs = 2;
13749	spec->input_mux = &spec->private_imux[0];
13750
13751	err = alc_auto_add_mic_boost(codec);
13752	if (err < 0)
13753		return err;
13754
13755	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13756
13757	return 1;
13758}
13759
13760#define alc268_auto_init_analog_input	alc882_auto_init_analog_input
13761#define alc268_auto_init_input_src	alc882_auto_init_input_src
13762
13763/* init callback for auto-configuration model -- overriding the default init */
13764static void alc268_auto_init(struct hda_codec *codec)
13765{
13766	struct alc_spec *spec = codec->spec;
13767	alc268_auto_init_multi_out(codec);
13768	alc268_auto_init_hp_out(codec);
13769	alc268_auto_init_mono_speaker_out(codec);
13770	alc268_auto_init_analog_input(codec);
13771	alc268_auto_init_input_src(codec);
13772	alc_auto_init_digital(codec);
13773	if (spec->unsol_event)
13774		alc_inithook(codec);
13775}
13776
13777/*
13778 * configuration and preset
13779 */
13780static const char * const alc268_models[ALC268_MODEL_LAST] = {
13781	[ALC267_QUANTA_IL1]	= "quanta-il1",
13782	[ALC268_3ST]		= "3stack",
13783	[ALC268_TOSHIBA]	= "toshiba",
13784	[ALC268_ACER]		= "acer",
13785	[ALC268_ACER_DMIC]	= "acer-dmic",
13786	[ALC268_ACER_ASPIRE_ONE]	= "acer-aspire",
13787	[ALC268_DELL]		= "dell",
13788	[ALC268_ZEPTO]		= "zepto",
13789#ifdef CONFIG_SND_DEBUG
13790	[ALC268_TEST]		= "test",
13791#endif
13792	[ALC268_AUTO]		= "auto",
13793};
13794
13795static struct snd_pci_quirk alc268_cfg_tbl[] = {
13796	SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13797	SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13798	SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13799	SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13800	SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13801	SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13802						ALC268_ACER_ASPIRE_ONE),
13803	SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13804	SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13805			"Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13806	/* almost compatible with toshiba but with optional digital outs;
13807	 * auto-probing seems working fine
13808	 */
13809	SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13810			   ALC268_AUTO),
13811	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13812	SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13813	SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13814	SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13815	SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13816	{}
13817};
13818
13819/* Toshiba laptops have no unique PCI SSID but only codec SSID */
13820static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13821	SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13822	SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13823	SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13824			   ALC268_TOSHIBA),
13825	{}
13826};
13827
13828static struct alc_config_preset alc268_presets[] = {
13829	[ALC267_QUANTA_IL1] = {
13830		.mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13831			    alc268_capture_nosrc_mixer },
13832		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13833				alc267_quanta_il1_verbs },
13834		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13835		.dac_nids = alc268_dac_nids,
13836		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13837		.adc_nids = alc268_adc_nids_alt,
13838		.hp_nid = 0x03,
13839		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13840		.channel_mode = alc268_modes,
13841		.unsol_event = alc_sku_unsol_event,
13842		.setup = alc267_quanta_il1_setup,
13843		.init_hook = alc_inithook,
13844	},
13845	[ALC268_3ST] = {
13846		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13847			    alc268_beep_mixer },
13848		.init_verbs = { alc268_base_init_verbs },
13849		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13850		.dac_nids = alc268_dac_nids,
13851                .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13852                .adc_nids = alc268_adc_nids_alt,
13853		.capsrc_nids = alc268_capsrc_nids,
13854		.hp_nid = 0x03,
13855		.dig_out_nid = ALC268_DIGOUT_NID,
13856		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13857		.channel_mode = alc268_modes,
13858		.input_mux = &alc268_capture_source,
13859	},
13860	[ALC268_TOSHIBA] = {
13861		.mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13862			    alc268_beep_mixer },
13863		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13864				alc268_toshiba_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		.input_mux = &alc268_capture_source,
13874		.unsol_event = alc268_toshiba_unsol_event,
13875		.setup = alc268_toshiba_setup,
13876		.init_hook = alc268_toshiba_automute,
13877	},
13878	[ALC268_ACER] = {
13879		.mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13880			    alc268_beep_mixer },
13881		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13882				alc268_acer_verbs },
13883		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13884		.dac_nids = alc268_dac_nids,
13885		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13886		.adc_nids = alc268_adc_nids_alt,
13887		.capsrc_nids = alc268_capsrc_nids,
13888		.hp_nid = 0x02,
13889		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13890		.channel_mode = alc268_modes,
13891		.input_mux = &alc268_acer_capture_source,
13892		.unsol_event = alc268_acer_unsol_event,
13893		.init_hook = alc268_acer_init_hook,
13894	},
13895	[ALC268_ACER_DMIC] = {
13896		.mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13897			    alc268_beep_mixer },
13898		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13899				alc268_acer_verbs },
13900		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13901		.dac_nids = alc268_dac_nids,
13902		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13903		.adc_nids = alc268_adc_nids_alt,
13904		.capsrc_nids = alc268_capsrc_nids,
13905		.hp_nid = 0x02,
13906		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13907		.channel_mode = alc268_modes,
13908		.input_mux = &alc268_acer_dmic_capture_source,
13909		.unsol_event = alc268_acer_unsol_event,
13910		.init_hook = alc268_acer_init_hook,
13911	},
13912	[ALC268_ACER_ASPIRE_ONE] = {
13913		.mixers = { alc268_acer_aspire_one_mixer,
13914			    alc268_beep_mixer,
13915			    alc268_capture_nosrc_mixer },
13916		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13917				alc268_acer_aspire_one_verbs },
13918		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13919		.dac_nids = alc268_dac_nids,
13920		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13921		.adc_nids = alc268_adc_nids_alt,
13922		.capsrc_nids = alc268_capsrc_nids,
13923		.hp_nid = 0x03,
13924		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13925		.channel_mode = alc268_modes,
13926		.unsol_event = alc268_acer_lc_unsol_event,
13927		.setup = alc268_acer_lc_setup,
13928		.init_hook = alc268_acer_lc_init_hook,
13929	},
13930	[ALC268_DELL] = {
13931		.mixers = { alc268_dell_mixer, alc268_beep_mixer,
13932			    alc268_capture_nosrc_mixer },
13933		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13934				alc268_dell_verbs },
13935		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13936		.dac_nids = alc268_dac_nids,
13937		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13938		.adc_nids = alc268_adc_nids_alt,
13939		.capsrc_nids = alc268_capsrc_nids,
13940		.hp_nid = 0x02,
13941		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13942		.channel_mode = alc268_modes,
13943		.unsol_event = alc_sku_unsol_event,
13944		.setup = alc268_dell_setup,
13945		.init_hook = alc_inithook,
13946	},
13947	[ALC268_ZEPTO] = {
13948		.mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13949			    alc268_beep_mixer },
13950		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13951				alc268_toshiba_verbs },
13952		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13953		.dac_nids = alc268_dac_nids,
13954		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13955		.adc_nids = alc268_adc_nids_alt,
13956		.capsrc_nids = alc268_capsrc_nids,
13957		.hp_nid = 0x03,
13958		.dig_out_nid = ALC268_DIGOUT_NID,
13959		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13960		.channel_mode = alc268_modes,
13961		.input_mux = &alc268_capture_source,
13962		.setup = alc268_toshiba_setup,
13963		.init_hook = alc268_toshiba_automute,
13964	},
13965#ifdef CONFIG_SND_DEBUG
13966	[ALC268_TEST] = {
13967		.mixers = { alc268_test_mixer, alc268_capture_mixer },
13968		.init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13969				alc268_volume_init_verbs },
13970		.num_dacs = ARRAY_SIZE(alc268_dac_nids),
13971		.dac_nids = alc268_dac_nids,
13972		.num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13973		.adc_nids = alc268_adc_nids_alt,
13974		.capsrc_nids = alc268_capsrc_nids,
13975		.hp_nid = 0x03,
13976		.dig_out_nid = ALC268_DIGOUT_NID,
13977		.num_channel_mode = ARRAY_SIZE(alc268_modes),
13978		.channel_mode = alc268_modes,
13979		.input_mux = &alc268_capture_source,
13980	},
13981#endif
13982};
13983
13984static int patch_alc268(struct hda_codec *codec)
13985{
13986	struct alc_spec *spec;
13987	int board_config;
13988	int i, has_beep, err;
13989
13990	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13991	if (spec == NULL)
13992		return -ENOMEM;
13993
13994	codec->spec = spec;
13995
13996	board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13997						  alc268_models,
13998						  alc268_cfg_tbl);
13999
14000	if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
14001		board_config = snd_hda_check_board_codec_sid_config(codec,
14002			ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
14003
14004	if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
14005		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14006		       codec->chip_name);
14007		board_config = ALC268_AUTO;
14008	}
14009
14010	if (board_config == ALC268_AUTO) {
14011		/* automatic parse from the BIOS config */
14012		err = alc268_parse_auto_config(codec);
14013		if (err < 0) {
14014			alc_free(codec);
14015			return err;
14016		} else if (!err) {
14017			printk(KERN_INFO
14018			       "hda_codec: Cannot set up configuration "
14019			       "from BIOS.  Using base mode...\n");
14020			board_config = ALC268_3ST;
14021		}
14022	}
14023
14024	if (board_config != ALC268_AUTO)
14025		setup_preset(codec, &alc268_presets[board_config]);
14026
14027	spec->stream_analog_playback = &alc268_pcm_analog_playback;
14028	spec->stream_analog_capture = &alc268_pcm_analog_capture;
14029	spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
14030
14031	spec->stream_digital_playback = &alc268_pcm_digital_playback;
14032
14033	has_beep = 0;
14034	for (i = 0; i < spec->num_mixers; i++) {
14035		if (spec->mixers[i] == alc268_beep_mixer) {
14036			has_beep = 1;
14037			break;
14038		}
14039	}
14040
14041	if (has_beep) {
14042		err = snd_hda_attach_beep_device(codec, 0x1);
14043		if (err < 0) {
14044			alc_free(codec);
14045			return err;
14046		}
14047		if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
14048			/* override the amp caps for beep generator */
14049			snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
14050					  (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
14051					  (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
14052					  (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
14053					  (0 << AC_AMPCAP_MUTE_SHIFT));
14054	}
14055
14056	if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
14057		/* check whether NID 0x07 is valid */
14058		unsigned int wcap = get_wcaps(codec, 0x07);
14059		int i;
14060
14061		spec->capsrc_nids = alc268_capsrc_nids;
14062		/* get type */
14063		wcap = get_wcaps_type(wcap);
14064		if (spec->auto_mic ||
14065		    wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
14066			spec->adc_nids = alc268_adc_nids_alt;
14067			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
14068			if (spec->auto_mic)
14069				fixup_automic_adc(codec);
14070			if (spec->auto_mic || spec->input_mux->num_items == 1)
14071				add_mixer(spec, alc268_capture_nosrc_mixer);
14072			else
14073				add_mixer(spec, alc268_capture_alt_mixer);
14074		} else {
14075			spec->adc_nids = alc268_adc_nids;
14076			spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
14077			add_mixer(spec, alc268_capture_mixer);
14078		}
14079	}
14080
14081	spec->vmaster_nid = 0x02;
14082
14083	codec->patch_ops = alc_patch_ops;
14084	if (board_config == ALC268_AUTO)
14085		spec->init_hook = alc268_auto_init;
14086
14087	alc_init_jacks(codec);
14088
14089	return 0;
14090}
14091
14092/*
14093 *  ALC269 channel source setting (2 channel)
14094 */
14095#define ALC269_DIGOUT_NID	ALC880_DIGOUT_NID
14096
14097#define alc269_dac_nids		alc260_dac_nids
14098
14099static hda_nid_t alc269_adc_nids[1] = {
14100	/* ADC1 */
14101	0x08,
14102};
14103
14104static hda_nid_t alc269_capsrc_nids[1] = {
14105	0x23,
14106};
14107
14108static hda_nid_t alc269vb_adc_nids[1] = {
14109	/* ADC1 */
14110	0x09,
14111};
14112
14113static hda_nid_t alc269vb_capsrc_nids[1] = {
14114	0x22,
14115};
14116
14117static hda_nid_t alc269_adc_candidates[] = {
14118	0x08, 0x09, 0x07,
14119};
14120
14121#define alc269_modes		alc260_modes
14122#define alc269_capture_source	alc880_lg_lw_capture_source
14123
14124static struct snd_kcontrol_new alc269_base_mixer[] = {
14125	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14126	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14127	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14128	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14129	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14130	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14131	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14132	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14133	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14134	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
14135	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14136	HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
14137	{ } /* end */
14138};
14139
14140static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
14141	/* output mixer control */
14142	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14143	{
14144		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14145		.name = "Master Playback Switch",
14146		.subdevice = HDA_SUBDEV_AMP_FLAG,
14147		.info = snd_hda_mixer_amp_switch_info,
14148		.get = snd_hda_mixer_amp_switch_get,
14149		.put = alc268_acer_master_sw_put,
14150		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14151	},
14152	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14153	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14154	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14155	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14156	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14157	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14158	{ }
14159};
14160
14161static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
14162	/* output mixer control */
14163	HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
14164	{
14165		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14166		.name = "Master Playback Switch",
14167		.subdevice = HDA_SUBDEV_AMP_FLAG,
14168		.info = snd_hda_mixer_amp_switch_info,
14169		.get = snd_hda_mixer_amp_switch_get,
14170		.put = alc268_acer_master_sw_put,
14171		.private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
14172	},
14173	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14174	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14175	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14176	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
14177	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
14178	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14179	HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
14180	HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
14181	HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x1b, 0, HDA_INPUT),
14182	{ }
14183};
14184
14185static struct snd_kcontrol_new alc269_laptop_mixer[] = {
14186	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14187	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14188	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14189	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14190	{ } /* end */
14191};
14192
14193static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
14194	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14195	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14196	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
14197	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14198	{ } /* end */
14199};
14200
14201static struct snd_kcontrol_new alc269_asus_mixer[] = {
14202	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14203	HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
14204	{ } /* end */
14205};
14206
14207/* capture mixer elements */
14208static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
14209	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14210	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14211	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14212	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14213	{ } /* end */
14214};
14215
14216static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
14217	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
14218	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
14219	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14220	{ } /* end */
14221};
14222
14223static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
14224	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14225	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14226	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14227	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
14228	{ } /* end */
14229};
14230
14231static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
14232	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
14233	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
14234	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
14235	{ } /* end */
14236};
14237
14238/* FSC amilo */
14239#define alc269_fujitsu_mixer	alc269_laptop_mixer
14240
14241static struct hda_verb alc269_quanta_fl1_verbs[] = {
14242	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14243	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14244	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14245	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14246	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14247	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14248	{ }
14249};
14250
14251static struct hda_verb alc269_lifebook_verbs[] = {
14252	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14253	{0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
14254	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14255	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14256	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14257	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14258	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14259	{0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
14260	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14261	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14262	{ }
14263};
14264
14265/* toggle speaker-output according to the hp-jack state */
14266static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
14267{
14268	unsigned int present;
14269	unsigned char bits;
14270
14271	present = snd_hda_jack_detect(codec, 0x15);
14272	bits = present ? HDA_AMP_MUTE : 0;
14273	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14274				 HDA_AMP_MUTE, bits);
14275	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14276				 HDA_AMP_MUTE, bits);
14277
14278	snd_hda_codec_write(codec, 0x20, 0,
14279			AC_VERB_SET_COEF_INDEX, 0x0c);
14280	snd_hda_codec_write(codec, 0x20, 0,
14281			AC_VERB_SET_PROC_COEF, 0x680);
14282
14283	snd_hda_codec_write(codec, 0x20, 0,
14284			AC_VERB_SET_COEF_INDEX, 0x0c);
14285	snd_hda_codec_write(codec, 0x20, 0,
14286			AC_VERB_SET_PROC_COEF, 0x480);
14287}
14288
14289/* toggle speaker-output according to the hp-jacks state */
14290static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
14291{
14292	unsigned int present;
14293	unsigned char bits;
14294
14295	/* Check laptop headphone socket */
14296	present = snd_hda_jack_detect(codec, 0x15);
14297
14298	/* Check port replicator headphone socket */
14299	present |= snd_hda_jack_detect(codec, 0x1a);
14300
14301	bits = present ? HDA_AMP_MUTE : 0;
14302	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14303				 HDA_AMP_MUTE, bits);
14304	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14305				 HDA_AMP_MUTE, bits);
14306
14307	snd_hda_codec_write(codec, 0x20, 0,
14308			AC_VERB_SET_COEF_INDEX, 0x0c);
14309	snd_hda_codec_write(codec, 0x20, 0,
14310			AC_VERB_SET_PROC_COEF, 0x680);
14311
14312	snd_hda_codec_write(codec, 0x20, 0,
14313			AC_VERB_SET_COEF_INDEX, 0x0c);
14314	snd_hda_codec_write(codec, 0x20, 0,
14315			AC_VERB_SET_PROC_COEF, 0x480);
14316}
14317
14318static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14319{
14320	unsigned int present_laptop;
14321	unsigned int present_dock;
14322
14323	present_laptop	= snd_hda_jack_detect(codec, 0x18);
14324	present_dock	= snd_hda_jack_detect(codec, 0x1b);
14325
14326	/* Laptop mic port overrides dock mic port, design decision */
14327	if (present_dock)
14328		snd_hda_codec_write(codec, 0x23, 0,
14329				AC_VERB_SET_CONNECT_SEL, 0x3);
14330	if (present_laptop)
14331		snd_hda_codec_write(codec, 0x23, 0,
14332				AC_VERB_SET_CONNECT_SEL, 0x0);
14333	if (!present_dock && !present_laptop)
14334		snd_hda_codec_write(codec, 0x23, 0,
14335				AC_VERB_SET_CONNECT_SEL, 0x1);
14336}
14337
14338static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14339				    unsigned int res)
14340{
14341	switch (res >> 26) {
14342	case ALC880_HP_EVENT:
14343		alc269_quanta_fl1_speaker_automute(codec);
14344		break;
14345	case ALC880_MIC_EVENT:
14346		alc_mic_automute(codec);
14347		break;
14348	}
14349}
14350
14351static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14352					unsigned int res)
14353{
14354	if ((res >> 26) == ALC880_HP_EVENT)
14355		alc269_lifebook_speaker_automute(codec);
14356	if ((res >> 26) == ALC880_MIC_EVENT)
14357		alc269_lifebook_mic_autoswitch(codec);
14358}
14359
14360static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14361{
14362	struct alc_spec *spec = codec->spec;
14363	spec->autocfg.hp_pins[0] = 0x15;
14364	spec->autocfg.speaker_pins[0] = 0x14;
14365	spec->ext_mic.pin = 0x18;
14366	spec->ext_mic.mux_idx = 0;
14367	spec->int_mic.pin = 0x19;
14368	spec->int_mic.mux_idx = 1;
14369	spec->auto_mic = 1;
14370}
14371
14372static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14373{
14374	alc269_quanta_fl1_speaker_automute(codec);
14375	alc_mic_automute(codec);
14376}
14377
14378static void alc269_lifebook_init_hook(struct hda_codec *codec)
14379{
14380	alc269_lifebook_speaker_automute(codec);
14381	alc269_lifebook_mic_autoswitch(codec);
14382}
14383
14384static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14385	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14386	{0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14387	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14388	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14389	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14390	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14391	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14392	{}
14393};
14394
14395static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14396	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14397	{0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14398	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14399	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14400	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14401	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14402	{}
14403};
14404
14405static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14406	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14407	{0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14408	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14409	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14410	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14411	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14412	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14413	{}
14414};
14415
14416static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14417	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14418	{0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14419	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14420	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14421	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14422	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14423	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14424	{}
14425};
14426
14427static struct hda_verb alc271_acer_dmic_verbs[] = {
14428	{0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14429	{0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14430	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14431	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14432	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14433	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14434	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14435	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14436	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14437	{0x22, AC_VERB_SET_CONNECT_SEL, 6},
14438	{ }
14439};
14440
14441/* toggle speaker-output according to the hp-jack state */
14442static void alc269_speaker_automute(struct hda_codec *codec)
14443{
14444	struct alc_spec *spec = codec->spec;
14445	unsigned int nid = spec->autocfg.hp_pins[0];
14446	unsigned int present;
14447	unsigned char bits;
14448
14449	present = snd_hda_jack_detect(codec, nid);
14450	bits = present ? HDA_AMP_MUTE : 0;
14451	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14452				 HDA_AMP_MUTE, bits);
14453	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14454				 HDA_AMP_MUTE, bits);
14455	snd_hda_input_jack_report(codec, nid);
14456}
14457
14458/* unsolicited event for HP jack sensing */
14459static void alc269_laptop_unsol_event(struct hda_codec *codec,
14460				     unsigned int res)
14461{
14462	switch (res >> 26) {
14463	case ALC880_HP_EVENT:
14464		alc269_speaker_automute(codec);
14465		break;
14466	case ALC880_MIC_EVENT:
14467		alc_mic_automute(codec);
14468		break;
14469	}
14470}
14471
14472static void alc269_laptop_amic_setup(struct hda_codec *codec)
14473{
14474	struct alc_spec *spec = codec->spec;
14475	spec->autocfg.hp_pins[0] = 0x15;
14476	spec->autocfg.speaker_pins[0] = 0x14;
14477	spec->ext_mic.pin = 0x18;
14478	spec->ext_mic.mux_idx = 0;
14479	spec->int_mic.pin = 0x19;
14480	spec->int_mic.mux_idx = 1;
14481	spec->auto_mic = 1;
14482}
14483
14484static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14485{
14486	struct alc_spec *spec = codec->spec;
14487	spec->autocfg.hp_pins[0] = 0x15;
14488	spec->autocfg.speaker_pins[0] = 0x14;
14489	spec->ext_mic.pin = 0x18;
14490	spec->ext_mic.mux_idx = 0;
14491	spec->int_mic.pin = 0x12;
14492	spec->int_mic.mux_idx = 5;
14493	spec->auto_mic = 1;
14494}
14495
14496static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14497{
14498	struct alc_spec *spec = codec->spec;
14499	spec->autocfg.hp_pins[0] = 0x21;
14500	spec->autocfg.speaker_pins[0] = 0x14;
14501	spec->ext_mic.pin = 0x18;
14502	spec->ext_mic.mux_idx = 0;
14503	spec->int_mic.pin = 0x19;
14504	spec->int_mic.mux_idx = 1;
14505	spec->auto_mic = 1;
14506}
14507
14508static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14509{
14510	struct alc_spec *spec = codec->spec;
14511	spec->autocfg.hp_pins[0] = 0x21;
14512	spec->autocfg.speaker_pins[0] = 0x14;
14513	spec->ext_mic.pin = 0x18;
14514	spec->ext_mic.mux_idx = 0;
14515	spec->int_mic.pin = 0x12;
14516	spec->int_mic.mux_idx = 6;
14517	spec->auto_mic = 1;
14518}
14519
14520static void alc269_laptop_inithook(struct hda_codec *codec)
14521{
14522	alc269_speaker_automute(codec);
14523	alc_mic_automute(codec);
14524}
14525
14526/*
14527 * generic initialization of ADC, input mixers and output mixers
14528 */
14529static struct hda_verb alc269_init_verbs[] = {
14530	/*
14531	 * Unmute ADC0 and set the default input to mic-in
14532	 */
14533	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14534
14535	/*
14536	 * Set up output mixers (0x02 - 0x03)
14537	 */
14538	/* set vol=0 to output mixers */
14539	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14540	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14541
14542	/* set up input amps for analog loopback */
14543	/* Amp Indices: DAC = 0, mixer = 1 */
14544	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14545	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14546	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14547	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14548	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14549	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14550
14551	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14552	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14553	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14554	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14555	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14556	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14557	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14558
14559	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14560	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14561
14562	/* FIXME: use Mux-type input source selection */
14563	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14564	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14565	{0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14566
14567	/* set EAPD */
14568	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14569	{ }
14570};
14571
14572static struct hda_verb alc269vb_init_verbs[] = {
14573	/*
14574	 * Unmute ADC0 and set the default input to mic-in
14575	 */
14576	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14577
14578	/*
14579	 * Set up output mixers (0x02 - 0x03)
14580	 */
14581	/* set vol=0 to output mixers */
14582	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14583	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14584
14585	/* set up input amps for analog loopback */
14586	/* Amp Indices: DAC = 0, mixer = 1 */
14587	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14588	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14589	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14590	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14591	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14592	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14593
14594	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14595	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14596	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14597	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14598	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14599	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14600	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14601
14602	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14603	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14604
14605	/* FIXME: use Mux-type input source selection */
14606	/* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14607	/* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14608	{0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14609
14610	/* set EAPD */
14611	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14612	{ }
14613};
14614
14615#define alc269_auto_create_multi_out_ctls \
14616	alc268_auto_create_multi_out_ctls
14617#define alc269_auto_create_input_ctls \
14618	alc268_auto_create_input_ctls
14619
14620#ifdef CONFIG_SND_HDA_POWER_SAVE
14621#define alc269_loopbacks	alc880_loopbacks
14622#endif
14623
14624/* pcm configuration: identical with ALC880 */
14625#define alc269_pcm_analog_playback	alc880_pcm_analog_playback
14626#define alc269_pcm_analog_capture	alc880_pcm_analog_capture
14627#define alc269_pcm_digital_playback	alc880_pcm_digital_playback
14628#define alc269_pcm_digital_capture	alc880_pcm_digital_capture
14629
14630static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14631	.substreams = 1,
14632	.channels_min = 2,
14633	.channels_max = 8,
14634	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14635	/* NID is set in alc_build_pcms */
14636	.ops = {
14637		.open = alc880_playback_pcm_open,
14638		.prepare = alc880_playback_pcm_prepare,
14639		.cleanup = alc880_playback_pcm_cleanup
14640	},
14641};
14642
14643static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14644	.substreams = 1,
14645	.channels_min = 2,
14646	.channels_max = 2,
14647	.rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14648	/* NID is set in alc_build_pcms */
14649};
14650
14651#ifdef CONFIG_SND_HDA_POWER_SAVE
14652static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14653{
14654	switch (codec->subsystem_id) {
14655	case 0x103c1586:
14656		return 1;
14657	}
14658	return 0;
14659}
14660
14661static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14662{
14663	/* update mute-LED according to the speaker mute state */
14664	if (nid == 0x01 || nid == 0x14) {
14665		int pinval;
14666		if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14667		    HDA_AMP_MUTE)
14668			pinval = 0x24;
14669		else
14670			pinval = 0x20;
14671		/* mic2 vref pin is used for mute LED control */
14672		snd_hda_codec_update_cache(codec, 0x19, 0,
14673					   AC_VERB_SET_PIN_WIDGET_CONTROL,
14674					   pinval);
14675	}
14676	return alc_check_power_status(codec, nid);
14677}
14678#endif /* CONFIG_SND_HDA_POWER_SAVE */
14679
14680static int alc275_setup_dual_adc(struct hda_codec *codec)
14681{
14682	struct alc_spec *spec = codec->spec;
14683
14684	if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14685		return 0;
14686	if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14687	    (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14688		if (spec->ext_mic.pin <= 0x12) {
14689			spec->private_adc_nids[0] = 0x08;
14690			spec->private_adc_nids[1] = 0x11;
14691			spec->private_capsrc_nids[0] = 0x23;
14692			spec->private_capsrc_nids[1] = 0x22;
14693		} else {
14694			spec->private_adc_nids[0] = 0x11;
14695			spec->private_adc_nids[1] = 0x08;
14696			spec->private_capsrc_nids[0] = 0x22;
14697			spec->private_capsrc_nids[1] = 0x23;
14698		}
14699		spec->adc_nids = spec->private_adc_nids;
14700		spec->capsrc_nids = spec->private_capsrc_nids;
14701		spec->num_adc_nids = 2;
14702		spec->dual_adc_switch = 1;
14703		snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14704			    spec->adc_nids[0], spec->adc_nids[1]);
14705		return 1;
14706	}
14707	return 0;
14708}
14709
14710/* different alc269-variants */
14711enum {
14712	ALC269_TYPE_NORMAL,
14713	ALC269_TYPE_ALC258,
14714	ALC269_TYPE_ALC259,
14715	ALC269_TYPE_ALC269VB,
14716	ALC269_TYPE_ALC270,
14717	ALC269_TYPE_ALC271X,
14718};
14719
14720/*
14721 * BIOS auto configuration
14722 */
14723static int alc269_parse_auto_config(struct hda_codec *codec)
14724{
14725	struct alc_spec *spec = codec->spec;
14726	int err;
14727	static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14728
14729	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14730					   alc269_ignore);
14731	if (err < 0)
14732		return err;
14733
14734	err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14735	if (err < 0)
14736		return err;
14737	if (spec->codec_variant == ALC269_TYPE_NORMAL)
14738		err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14739	else
14740		err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0,
14741						 0x22, 0);
14742	if (err < 0)
14743		return err;
14744
14745	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14746
14747	alc_auto_parse_digital(codec);
14748
14749	if (spec->kctls.list)
14750		add_mixer(spec, spec->kctls.list);
14751
14752	if (spec->codec_variant != ALC269_TYPE_NORMAL) {
14753		add_verb(spec, alc269vb_init_verbs);
14754		alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14755	} else {
14756		add_verb(spec, alc269_init_verbs);
14757		alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14758	}
14759
14760	spec->num_mux_defs = 1;
14761	spec->input_mux = &spec->private_imux[0];
14762
14763	if (!alc275_setup_dual_adc(codec))
14764		fillup_priv_adc_nids(codec, alc269_adc_candidates,
14765				     sizeof(alc269_adc_candidates));
14766
14767	err = alc_auto_add_mic_boost(codec);
14768	if (err < 0)
14769		return err;
14770
14771	if (!spec->cap_mixer && !spec->no_analog)
14772		set_capture_mixer(codec);
14773
14774	return 1;
14775}
14776
14777#define alc269_auto_init_multi_out	alc268_auto_init_multi_out
14778#define alc269_auto_init_hp_out		alc268_auto_init_hp_out
14779#define alc269_auto_init_analog_input	alc882_auto_init_analog_input
14780#define alc269_auto_init_input_src	alc882_auto_init_input_src
14781
14782
14783/* init callback for auto-configuration model -- overriding the default init */
14784static void alc269_auto_init(struct hda_codec *codec)
14785{
14786	struct alc_spec *spec = codec->spec;
14787	alc269_auto_init_multi_out(codec);
14788	alc269_auto_init_hp_out(codec);
14789	alc269_auto_init_analog_input(codec);
14790	if (!spec->dual_adc_switch)
14791		alc269_auto_init_input_src(codec);
14792	alc_auto_init_digital(codec);
14793	if (spec->unsol_event)
14794		alc_inithook(codec);
14795}
14796
14797#ifdef SND_HDA_NEEDS_RESUME
14798static void alc269_toggle_power_output(struct hda_codec *codec, int power_up)
14799{
14800	int val = alc_read_coef_idx(codec, 0x04);
14801	if (power_up)
14802		val |= 1 << 11;
14803	else
14804		val &= ~(1 << 11);
14805	alc_write_coef_idx(codec, 0x04, val);
14806}
14807
14808#ifdef CONFIG_SND_HDA_POWER_SAVE
14809static int alc269_suspend(struct hda_codec *codec, pm_message_t state)
14810{
14811	struct alc_spec *spec = codec->spec;
14812
14813	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017)
14814		alc269_toggle_power_output(codec, 0);
14815	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14816		alc269_toggle_power_output(codec, 0);
14817		msleep(150);
14818	}
14819
14820	alc_shutup(codec);
14821	if (spec && spec->power_hook)
14822		spec->power_hook(codec);
14823	return 0;
14824}
14825#endif /* CONFIG_SND_HDA_POWER_SAVE */
14826
14827static int alc269_resume(struct hda_codec *codec)
14828{
14829	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
14830		alc269_toggle_power_output(codec, 0);
14831		msleep(150);
14832	}
14833
14834	codec->patch_ops.init(codec);
14835
14836	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
14837		alc269_toggle_power_output(codec, 1);
14838		msleep(200);
14839	}
14840
14841	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018)
14842		alc269_toggle_power_output(codec, 1);
14843
14844	snd_hda_codec_resume_amp(codec);
14845	snd_hda_codec_resume_cache(codec);
14846	hda_call_check_power_status(codec, 0x01);
14847	return 0;
14848}
14849#endif /* SND_HDA_NEEDS_RESUME */
14850
14851static void alc269_fixup_hweq(struct hda_codec *codec,
14852			       const struct alc_fixup *fix, int action)
14853{
14854	int coef;
14855
14856	if (action != ALC_FIXUP_ACT_INIT)
14857		return;
14858	coef = alc_read_coef_idx(codec, 0x1e);
14859	alc_write_coef_idx(codec, 0x1e, coef | 0x80);
14860}
14861
14862enum {
14863	ALC269_FIXUP_SONY_VAIO,
14864	ALC275_FIXUP_SONY_VAIO_GPIO2,
14865	ALC269_FIXUP_DELL_M101Z,
14866	ALC269_FIXUP_SKU_IGNORE,
14867	ALC269_FIXUP_ASUS_G73JW,
14868	ALC269_FIXUP_LENOVO_EAPD,
14869	ALC275_FIXUP_SONY_HWEQ,
14870};
14871
14872static const struct alc_fixup alc269_fixups[] = {
14873	[ALC269_FIXUP_SONY_VAIO] = {
14874		.type = ALC_FIXUP_VERBS,
14875		.v.verbs = (const struct hda_verb[]) {
14876			{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14877			{}
14878		}
14879	},
14880	[ALC275_FIXUP_SONY_VAIO_GPIO2] = {
14881		.type = ALC_FIXUP_VERBS,
14882		.v.verbs = (const struct hda_verb[]) {
14883			{0x01, AC_VERB_SET_GPIO_MASK, 0x04},
14884			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x04},
14885			{0x01, AC_VERB_SET_GPIO_DATA, 0x00},
14886			{ }
14887		},
14888		.chained = true,
14889		.chain_id = ALC269_FIXUP_SONY_VAIO
14890	},
14891	[ALC269_FIXUP_DELL_M101Z] = {
14892		.type = ALC_FIXUP_VERBS,
14893		.v.verbs = (const struct hda_verb[]) {
14894			/* Enables internal speaker */
14895			{0x20, AC_VERB_SET_COEF_INDEX, 13},
14896			{0x20, AC_VERB_SET_PROC_COEF, 0x4040},
14897			{}
14898		}
14899	},
14900	[ALC269_FIXUP_SKU_IGNORE] = {
14901		.type = ALC_FIXUP_SKU,
14902		.v.sku = ALC_FIXUP_SKU_IGNORE,
14903	},
14904	[ALC269_FIXUP_ASUS_G73JW] = {
14905		.type = ALC_FIXUP_PINS,
14906		.v.pins = (const struct alc_pincfg[]) {
14907			{ 0x17, 0x99130111 }, /* subwoofer */
14908			{ }
14909		}
14910	},
14911	[ALC269_FIXUP_LENOVO_EAPD] = {
14912		.type = ALC_FIXUP_VERBS,
14913		.v.verbs = (const struct hda_verb[]) {
14914			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
14915			{}
14916		}
14917	},
14918	[ALC275_FIXUP_SONY_HWEQ] = {
14919		.type = ALC_FIXUP_FUNC,
14920		.v.func = alc269_fixup_hweq,
14921		.chained = true,
14922		.chain_id = ALC275_FIXUP_SONY_VAIO_GPIO2
14923	}
14924};
14925
14926static struct snd_pci_quirk alc269_fixup_tbl[] = {
14927	SND_PCI_QUIRK(0x104d, 0x9073, "Sony VAIO", ALC275_FIXUP_SONY_VAIO_GPIO2),
14928	SND_PCI_QUIRK(0x104d, 0x907b, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14929	SND_PCI_QUIRK(0x104d, 0x9084, "Sony VAIO", ALC275_FIXUP_SONY_HWEQ),
14930	SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14931	SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
14932	SND_PCI_QUIRK(0x17aa, 0x20f2, "Thinkpad SL410/510", ALC269_FIXUP_SKU_IGNORE),
14933	SND_PCI_QUIRK(0x17aa, 0x215e, "Thinkpad L512", ALC269_FIXUP_SKU_IGNORE),
14934	SND_PCI_QUIRK(0x17aa, 0x21b8, "Thinkpad Edge 14", ALC269_FIXUP_SKU_IGNORE),
14935	SND_PCI_QUIRK(0x17aa, 0x21ca, "Thinkpad L412", ALC269_FIXUP_SKU_IGNORE),
14936	SND_PCI_QUIRK(0x17aa, 0x21e9, "Thinkpad Edge 15", ALC269_FIXUP_SKU_IGNORE),
14937	SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
14938	SND_PCI_QUIRK(0x17aa, 0x9e54, "LENOVO NB", ALC269_FIXUP_LENOVO_EAPD),
14939	{}
14940};
14941
14942
14943/*
14944 * configuration and preset
14945 */
14946static const char * const alc269_models[ALC269_MODEL_LAST] = {
14947	[ALC269_BASIC]			= "basic",
14948	[ALC269_QUANTA_FL1]		= "quanta",
14949	[ALC269_AMIC]			= "laptop-amic",
14950	[ALC269_DMIC]			= "laptop-dmic",
14951	[ALC269_FUJITSU]		= "fujitsu",
14952	[ALC269_LIFEBOOK]		= "lifebook",
14953	[ALC269_AUTO]			= "auto",
14954};
14955
14956static struct snd_pci_quirk alc269_cfg_tbl[] = {
14957	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14958	SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14959	SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14960		      ALC269_AMIC),
14961	SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14962	SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14963	SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14964	SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14965	SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14966	SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14967	SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14968	SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14969	SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14970	SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82JV", ALC269VB_AMIC),
14971	SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14972	SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14973	SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14974	SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14975	SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14976	SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14977	SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14978	SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14979	SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14980	SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14981	SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14982	SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14983	SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14984	SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14985	SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14986	SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14987	SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14988	SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14989	SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14990	SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14991	SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14992	SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14993	SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14994	SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14995	SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14996	SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14997	SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14998		      ALC269_DMIC),
14999	SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
15000		      ALC269_DMIC),
15001	SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
15002	SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
15003	SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
15004	SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
15005	SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
15006	SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
15007	SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
15008	SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
15009	SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
15010	SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
15011	{}
15012};
15013
15014static struct alc_config_preset alc269_presets[] = {
15015	[ALC269_BASIC] = {
15016		.mixers = { alc269_base_mixer },
15017		.init_verbs = { alc269_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		.input_mux = &alc269_capture_source,
15024	},
15025	[ALC269_QUANTA_FL1] = {
15026		.mixers = { alc269_quanta_fl1_mixer },
15027		.init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
15028		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15029		.dac_nids = alc269_dac_nids,
15030		.hp_nid = 0x03,
15031		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15032		.channel_mode = alc269_modes,
15033		.input_mux = &alc269_capture_source,
15034		.unsol_event = alc269_quanta_fl1_unsol_event,
15035		.setup = alc269_quanta_fl1_setup,
15036		.init_hook = alc269_quanta_fl1_init_hook,
15037	},
15038	[ALC269_AMIC] = {
15039		.mixers = { alc269_laptop_mixer },
15040		.cap_mixer = alc269_laptop_analog_capture_mixer,
15041		.init_verbs = { alc269_init_verbs,
15042				alc269_laptop_amic_init_verbs },
15043		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15044		.dac_nids = alc269_dac_nids,
15045		.hp_nid = 0x03,
15046		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15047		.channel_mode = alc269_modes,
15048		.unsol_event = alc269_laptop_unsol_event,
15049		.setup = alc269_laptop_amic_setup,
15050		.init_hook = alc269_laptop_inithook,
15051	},
15052	[ALC269_DMIC] = {
15053		.mixers = { alc269_laptop_mixer },
15054		.cap_mixer = alc269_laptop_digital_capture_mixer,
15055		.init_verbs = { alc269_init_verbs,
15056				alc269_laptop_dmic_init_verbs },
15057		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15058		.dac_nids = alc269_dac_nids,
15059		.hp_nid = 0x03,
15060		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15061		.channel_mode = alc269_modes,
15062		.unsol_event = alc269_laptop_unsol_event,
15063		.setup = alc269_laptop_dmic_setup,
15064		.init_hook = alc269_laptop_inithook,
15065	},
15066	[ALC269VB_AMIC] = {
15067		.mixers = { alc269vb_laptop_mixer },
15068		.cap_mixer = alc269vb_laptop_analog_capture_mixer,
15069		.init_verbs = { alc269vb_init_verbs,
15070				alc269vb_laptop_amic_init_verbs },
15071		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15072		.dac_nids = alc269_dac_nids,
15073		.hp_nid = 0x03,
15074		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15075		.channel_mode = alc269_modes,
15076		.unsol_event = alc269_laptop_unsol_event,
15077		.setup = alc269vb_laptop_amic_setup,
15078		.init_hook = alc269_laptop_inithook,
15079	},
15080	[ALC269VB_DMIC] = {
15081		.mixers = { alc269vb_laptop_mixer },
15082		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
15083		.init_verbs = { alc269vb_init_verbs,
15084				alc269vb_laptop_dmic_init_verbs },
15085		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15086		.dac_nids = alc269_dac_nids,
15087		.hp_nid = 0x03,
15088		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15089		.channel_mode = alc269_modes,
15090		.unsol_event = alc269_laptop_unsol_event,
15091		.setup = alc269vb_laptop_dmic_setup,
15092		.init_hook = alc269_laptop_inithook,
15093	},
15094	[ALC269_FUJITSU] = {
15095		.mixers = { alc269_fujitsu_mixer },
15096		.cap_mixer = alc269_laptop_digital_capture_mixer,
15097		.init_verbs = { alc269_init_verbs,
15098				alc269_laptop_dmic_init_verbs },
15099		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15100		.dac_nids = alc269_dac_nids,
15101		.hp_nid = 0x03,
15102		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15103		.channel_mode = alc269_modes,
15104		.unsol_event = alc269_laptop_unsol_event,
15105		.setup = alc269_laptop_dmic_setup,
15106		.init_hook = alc269_laptop_inithook,
15107	},
15108	[ALC269_LIFEBOOK] = {
15109		.mixers = { alc269_lifebook_mixer },
15110		.init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
15111		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15112		.dac_nids = alc269_dac_nids,
15113		.hp_nid = 0x03,
15114		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15115		.channel_mode = alc269_modes,
15116		.input_mux = &alc269_capture_source,
15117		.unsol_event = alc269_lifebook_unsol_event,
15118		.init_hook = alc269_lifebook_init_hook,
15119	},
15120	[ALC271_ACER] = {
15121		.mixers = { alc269_asus_mixer },
15122		.cap_mixer = alc269vb_laptop_digital_capture_mixer,
15123		.init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
15124		.num_dacs = ARRAY_SIZE(alc269_dac_nids),
15125		.dac_nids = alc269_dac_nids,
15126		.adc_nids = alc262_dmic_adc_nids,
15127		.num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
15128		.capsrc_nids = alc262_dmic_capsrc_nids,
15129		.num_channel_mode = ARRAY_SIZE(alc269_modes),
15130		.channel_mode = alc269_modes,
15131		.input_mux = &alc269_capture_source,
15132		.dig_out_nid = ALC880_DIGOUT_NID,
15133		.unsol_event = alc_sku_unsol_event,
15134		.setup = alc269vb_laptop_dmic_setup,
15135		.init_hook = alc_inithook,
15136	},
15137};
15138
15139static int alc269_fill_coef(struct hda_codec *codec)
15140{
15141	int val;
15142
15143	if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) {
15144		alc_write_coef_idx(codec, 0xf, 0x960b);
15145		alc_write_coef_idx(codec, 0xe, 0x8817);
15146	}
15147
15148	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) {
15149		alc_write_coef_idx(codec, 0xf, 0x960b);
15150		alc_write_coef_idx(codec, 0xe, 0x8814);
15151	}
15152
15153	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) {
15154		val = alc_read_coef_idx(codec, 0x04);
15155		/* Power up output pin */
15156		alc_write_coef_idx(codec, 0x04, val | (1<<11));
15157	}
15158
15159	if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) {
15160		val = alc_read_coef_idx(codec, 0xd);
15161		if ((val & 0x0c00) >> 10 != 0x1) {
15162			/* Capless ramp up clock control */
15163			alc_write_coef_idx(codec, 0xd, val | 1<<10);
15164		}
15165		val = alc_read_coef_idx(codec, 0x17);
15166		if ((val & 0x01c0) >> 6 != 0x4) {
15167			/* Class D power on reset */
15168			alc_write_coef_idx(codec, 0x17, val | 1<<7);
15169		}
15170	}
15171	return 0;
15172}
15173
15174static int patch_alc269(struct hda_codec *codec)
15175{
15176	struct alc_spec *spec;
15177	int board_config, coef;
15178	int err;
15179
15180	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15181	if (spec == NULL)
15182		return -ENOMEM;
15183
15184	codec->spec = spec;
15185
15186	alc_auto_parse_customize_define(codec);
15187
15188	if (codec->vendor_id == 0x10ec0269) {
15189		coef = alc_read_coef_idx(codec, 0);
15190		if ((coef & 0x00f0) == 0x0010) {
15191			if (codec->bus->pci->subsystem_vendor == 0x1025 &&
15192			    spec->cdefine.platform_type == 1) {
15193				alc_codec_rename(codec, "ALC271X");
15194				spec->codec_variant = ALC269_TYPE_ALC271X;
15195			} else if ((coef & 0xf000) == 0x1000) {
15196				spec->codec_variant = ALC269_TYPE_ALC270;
15197			} else if ((coef & 0xf000) == 0x2000) {
15198				alc_codec_rename(codec, "ALC259");
15199				spec->codec_variant = ALC269_TYPE_ALC259;
15200			} else if ((coef & 0xf000) == 0x3000) {
15201				alc_codec_rename(codec, "ALC258");
15202				spec->codec_variant = ALC269_TYPE_ALC258;
15203			} else {
15204				alc_codec_rename(codec, "ALC269VB");
15205				spec->codec_variant = ALC269_TYPE_ALC269VB;
15206			}
15207		} else
15208			alc_fix_pll_init(codec, 0x20, 0x04, 15);
15209		alc269_fill_coef(codec);
15210	}
15211
15212	board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
15213						  alc269_models,
15214						  alc269_cfg_tbl);
15215
15216	if (board_config < 0) {
15217		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15218		       codec->chip_name);
15219		board_config = ALC269_AUTO;
15220	}
15221
15222	if (board_config == ALC269_AUTO) {
15223		alc_pick_fixup(codec, NULL, alc269_fixup_tbl, alc269_fixups);
15224		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
15225	}
15226
15227	if (board_config == ALC269_AUTO) {
15228		/* automatic parse from the BIOS config */
15229		err = alc269_parse_auto_config(codec);
15230		if (err < 0) {
15231			alc_free(codec);
15232			return err;
15233		} else if (!err) {
15234			printk(KERN_INFO
15235			       "hda_codec: Cannot set up configuration "
15236			       "from BIOS.  Using base mode...\n");
15237			board_config = ALC269_BASIC;
15238		}
15239	}
15240
15241	if (has_cdefine_beep(codec)) {
15242		err = snd_hda_attach_beep_device(codec, 0x1);
15243		if (err < 0) {
15244			alc_free(codec);
15245			return err;
15246		}
15247	}
15248
15249	if (board_config != ALC269_AUTO)
15250		setup_preset(codec, &alc269_presets[board_config]);
15251
15252	if (board_config == ALC269_QUANTA_FL1) {
15253		/* Due to a hardware problem on Lenovo Ideadpad, we need to
15254		 * fix the sample rate of analog I/O to 44.1kHz
15255		 */
15256		spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
15257		spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
15258	} else if (spec->dual_adc_switch) {
15259		spec->stream_analog_playback = &alc269_pcm_analog_playback;
15260		/* switch ADC dynamically */
15261		spec->stream_analog_capture = &dualmic_pcm_analog_capture;
15262	} else {
15263		spec->stream_analog_playback = &alc269_pcm_analog_playback;
15264		spec->stream_analog_capture = &alc269_pcm_analog_capture;
15265	}
15266	spec->stream_digital_playback = &alc269_pcm_digital_playback;
15267	spec->stream_digital_capture = &alc269_pcm_digital_capture;
15268
15269	if (!spec->adc_nids) { /* wasn't filled automatically? use default */
15270		if (spec->codec_variant == ALC269_TYPE_NORMAL) {
15271			spec->adc_nids = alc269_adc_nids;
15272			spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
15273			spec->capsrc_nids = alc269_capsrc_nids;
15274		} else {
15275			spec->adc_nids = alc269vb_adc_nids;
15276			spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
15277			spec->capsrc_nids = alc269vb_capsrc_nids;
15278		}
15279	}
15280
15281	if (!spec->cap_mixer)
15282		set_capture_mixer(codec);
15283	if (has_cdefine_beep(codec))
15284		set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
15285
15286	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
15287
15288	spec->vmaster_nid = 0x02;
15289
15290	codec->patch_ops = alc_patch_ops;
15291#ifdef CONFIG_SND_HDA_POWER_SAVE
15292	codec->patch_ops.suspend = alc269_suspend;
15293#endif
15294#ifdef SND_HDA_NEEDS_RESUME
15295	codec->patch_ops.resume = alc269_resume;
15296#endif
15297	if (board_config == ALC269_AUTO)
15298		spec->init_hook = alc269_auto_init;
15299
15300	alc_init_jacks(codec);
15301#ifdef CONFIG_SND_HDA_POWER_SAVE
15302	if (!spec->loopback.amplist)
15303		spec->loopback.amplist = alc269_loopbacks;
15304	if (alc269_mic2_for_mute_led(codec))
15305		codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
15306#endif
15307
15308	return 0;
15309}
15310
15311/*
15312 *  ALC861 channel source setting (2/6 channel selection for 3-stack)
15313 */
15314
15315/*
15316 * set the path ways for 2 channel output
15317 * need to set the codec line out and mic 1 pin widgets to inputs
15318 */
15319static struct hda_verb alc861_threestack_ch2_init[] = {
15320	/* set pin widget 1Ah (line in) for input */
15321	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15322	/* set pin widget 18h (mic1/2) for input, for mic also enable
15323	 * the vref
15324	 */
15325	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15326
15327	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15328#if 0
15329	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15330	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15331#endif
15332	{ } /* end */
15333};
15334/*
15335 * 6ch mode
15336 * need to set the codec line out and mic 1 pin widgets to outputs
15337 */
15338static struct hda_verb alc861_threestack_ch6_init[] = {
15339	/* set pin widget 1Ah (line in) for output (Back Surround)*/
15340	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15341	/* set pin widget 18h (mic1) for output (CLFE)*/
15342	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15343
15344	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15345	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15346
15347	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15348#if 0
15349	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15350	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15351#endif
15352	{ } /* end */
15353};
15354
15355static struct hda_channel_mode alc861_threestack_modes[2] = {
15356	{ 2, alc861_threestack_ch2_init },
15357	{ 6, alc861_threestack_ch6_init },
15358};
15359/* Set mic1 as input and unmute the mixer */
15360static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
15361	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15362	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15363	{ } /* end */
15364};
15365/* Set mic1 as output and mute mixer */
15366static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
15367	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15368	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15369	{ } /* end */
15370};
15371
15372static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
15373	{ 2, alc861_uniwill_m31_ch2_init },
15374	{ 4, alc861_uniwill_m31_ch4_init },
15375};
15376
15377/* Set mic1 and line-in as input and unmute the mixer */
15378static struct hda_verb alc861_asus_ch2_init[] = {
15379	/* set pin widget 1Ah (line in) for input */
15380	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15381	/* set pin widget 18h (mic1/2) for input, for mic also enable
15382	 * the vref
15383	 */
15384	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15385
15386	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
15387#if 0
15388	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
15389	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
15390#endif
15391	{ } /* end */
15392};
15393/* Set mic1 nad line-in as output and mute mixer */
15394static struct hda_verb alc861_asus_ch6_init[] = {
15395	/* set pin widget 1Ah (line in) for output (Back Surround)*/
15396	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15397	/* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15398	/* set pin widget 18h (mic1) for output (CLFE)*/
15399	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15400	/* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
15401	{ 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
15402	{ 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
15403
15404	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
15405#if 0
15406	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
15407	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
15408#endif
15409	{ } /* end */
15410};
15411
15412static struct hda_channel_mode alc861_asus_modes[2] = {
15413	{ 2, alc861_asus_ch2_init },
15414	{ 6, alc861_asus_ch6_init },
15415};
15416
15417/* patch-ALC861 */
15418
15419static struct snd_kcontrol_new alc861_base_mixer[] = {
15420        /* output mixer control */
15421	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15422	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15423	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15424	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15425	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15426
15427        /*Input mixer control */
15428	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15429	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15430	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15431	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15432	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15433	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15434	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15435	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15436	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15437	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15438
15439	{ } /* end */
15440};
15441
15442static struct snd_kcontrol_new alc861_3ST_mixer[] = {
15443        /* output mixer control */
15444	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15445	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15446	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15447	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15448	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15449
15450	/* Input mixer control */
15451	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15452	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15453	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15454	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15455	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15456	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15457	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15458	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15459	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15460	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15461
15462	{
15463		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15464		.name = "Channel Mode",
15465		.info = alc_ch_mode_info,
15466		.get = alc_ch_mode_get,
15467		.put = alc_ch_mode_put,
15468                .private_value = ARRAY_SIZE(alc861_threestack_modes),
15469	},
15470	{ } /* end */
15471};
15472
15473static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
15474        /* output mixer control */
15475	HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15476	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15477	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15478
15479	{ } /* end */
15480};
15481
15482static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
15483        /* output mixer control */
15484	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15485	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15486	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15487	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15488	/*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
15489
15490	/* Input mixer control */
15491	/* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15492	   HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
15493	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15494	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15495	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15496	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15497	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15498	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15499	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15500	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
15501
15502	{
15503		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15504		.name = "Channel Mode",
15505		.info = alc_ch_mode_info,
15506		.get = alc_ch_mode_get,
15507		.put = alc_ch_mode_put,
15508                .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
15509	},
15510	{ } /* end */
15511};
15512
15513static struct snd_kcontrol_new alc861_asus_mixer[] = {
15514        /* output mixer control */
15515	HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15516	HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15517	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15518	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15519	HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15520
15521	/* Input mixer control */
15522	HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15523	HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15524	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15525	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15526	HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15527	HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15528	HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15529	HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15530	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15531	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15532
15533	{
15534		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15535		.name = "Channel Mode",
15536		.info = alc_ch_mode_info,
15537		.get = alc_ch_mode_get,
15538		.put = alc_ch_mode_put,
15539                .private_value = ARRAY_SIZE(alc861_asus_modes),
15540	},
15541	{ }
15542};
15543
15544/* additional mixer */
15545static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15546	HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15547	HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15548	{ }
15549};
15550
15551/*
15552 * generic initialization of ADC, input mixers and output mixers
15553 */
15554static struct hda_verb alc861_base_init_verbs[] = {
15555	/*
15556	 * Unmute ADC0 and set the default input to mic-in
15557	 */
15558	/* port-A for surround (rear panel) */
15559	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15560	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15561	/* port-B for mic-in (rear panel) with vref */
15562	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15563	/* port-C for line-in (rear panel) */
15564	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15565	/* port-D for Front */
15566	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15567	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15568	/* port-E for HP out (front panel) */
15569	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15570	/* route front PCM to HP */
15571	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15572	/* port-F for mic-in (front panel) with vref */
15573	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15574	/* port-G for CLFE (rear panel) */
15575	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15576	{ 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15577	/* port-H for side (rear panel) */
15578	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15579	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15580	/* CD-in */
15581	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15582	/* route front mic to ADC1*/
15583	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15584	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15585
15586	/* Unmute DAC0~3 & spdif out*/
15587	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15588	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15589	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15590	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15591	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15592
15593	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15594	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15595        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15596	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15597        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15598
15599	/* Unmute Stereo Mixer 15 */
15600	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15601	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15602	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15603	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15604
15605	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15606	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15607	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15608	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15609	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15610	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15611	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15612	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15613	/* hp used DAC 3 (Front) */
15614	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15615        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15616
15617	{ }
15618};
15619
15620static struct hda_verb alc861_threestack_init_verbs[] = {
15621	/*
15622	 * Unmute ADC0 and set the default input to mic-in
15623	 */
15624	/* port-A for surround (rear panel) */
15625	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15626	/* port-B for mic-in (rear panel) with vref */
15627	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15628	/* port-C for line-in (rear panel) */
15629	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15630	/* port-D for Front */
15631	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15632	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15633	/* port-E for HP out (front panel) */
15634	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15635	/* route front PCM to HP */
15636	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15637	/* port-F for mic-in (front panel) with vref */
15638	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15639	/* port-G for CLFE (rear panel) */
15640	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15641	/* port-H for side (rear panel) */
15642	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15643	/* CD-in */
15644	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15645	/* route front mic to ADC1*/
15646	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15647	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15648	/* Unmute DAC0~3 & spdif out*/
15649	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15650	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15651	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15652	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15653	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15654
15655	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15656	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15657        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15658	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15659        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15660
15661	/* Unmute Stereo Mixer 15 */
15662	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15663	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15664	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15665	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15666
15667	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15668	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15669	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15670	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15671	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15672	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15673	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15674	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15675	/* hp used DAC 3 (Front) */
15676	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15677        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15678	{ }
15679};
15680
15681static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15682	/*
15683	 * Unmute ADC0 and set the default input to mic-in
15684	 */
15685	/* port-A for surround (rear panel) */
15686	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15687	/* port-B for mic-in (rear panel) with vref */
15688	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15689	/* port-C for line-in (rear panel) */
15690	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15691	/* port-D for Front */
15692	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15693	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15694	/* port-E for HP out (front panel) */
15695	/* this has to be set to VREF80 */
15696	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15697	/* route front PCM to HP */
15698	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15699	/* port-F for mic-in (front panel) with vref */
15700	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15701	/* port-G for CLFE (rear panel) */
15702	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15703	/* port-H for side (rear panel) */
15704	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15705	/* CD-in */
15706	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15707	/* route front mic to ADC1*/
15708	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15709	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15710	/* Unmute DAC0~3 & spdif out*/
15711	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15712	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15713	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15714	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15715	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15716
15717	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15718	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15719        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15720	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15721        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15722
15723	/* Unmute Stereo Mixer 15 */
15724	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15725	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15726	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15727	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15728
15729	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15730	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15731	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15732	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15733	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15734	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15735	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15736	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15737	/* hp used DAC 3 (Front) */
15738	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15739        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15740	{ }
15741};
15742
15743static struct hda_verb alc861_asus_init_verbs[] = {
15744	/*
15745	 * Unmute ADC0 and set the default input to mic-in
15746	 */
15747	/* port-A for surround (rear panel)
15748	 * according to codec#0 this is the HP jack
15749	 */
15750	{ 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15751	/* route front PCM to HP */
15752	{ 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15753	/* port-B for mic-in (rear panel) with vref */
15754	{ 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15755	/* port-C for line-in (rear panel) */
15756	{ 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15757	/* port-D for Front */
15758	{ 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15759	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15760	/* port-E for HP out (front panel) */
15761	/* this has to be set to VREF80 */
15762	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15763	/* route front PCM to HP */
15764	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15765	/* port-F for mic-in (front panel) with vref */
15766	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15767	/* port-G for CLFE (rear panel) */
15768	{ 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15769	/* port-H for side (rear panel) */
15770	{ 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15771	/* CD-in */
15772	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15773	/* route front mic to ADC1*/
15774	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15775	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15776	/* Unmute DAC0~3 & spdif out*/
15777	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15778	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15779	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15780	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15781	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15782	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15783	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15784        {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15785	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15786        {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15787
15788	/* Unmute Stereo Mixer 15 */
15789	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15790	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15791	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15792	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15793
15794	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15795	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15796	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15797	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15798	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15799	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15800	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15801	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15802	/* hp used DAC 3 (Front) */
15803	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15804	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15805	{ }
15806};
15807
15808/* additional init verbs for ASUS laptops */
15809static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15810	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15811	{ 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15812	{ }
15813};
15814
15815/*
15816 * generic initialization of ADC, input mixers and output mixers
15817 */
15818static struct hda_verb alc861_auto_init_verbs[] = {
15819	/*
15820	 * Unmute ADC0 and set the default input to mic-in
15821	 */
15822	/* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15823	{0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15824
15825	/* Unmute DAC0~3 & spdif out*/
15826	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15827	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15828	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15829	{0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15830	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15831
15832	/* Unmute Mixer 14 (mic) 1c (Line in)*/
15833	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15834	{0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15835	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15836	{0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15837
15838	/* Unmute Stereo Mixer 15 */
15839	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15840	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15841	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15842	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15843
15844	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15845	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15846	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15847	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15848	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15849	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15850	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15851	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15852
15853	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15854	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15855	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15856	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15857	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15858	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15859	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15860	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15861
15862	{0x08, AC_VERB_SET_CONNECT_SEL, 0x00},	/* set Mic 1 */
15863
15864	{ }
15865};
15866
15867static struct hda_verb alc861_toshiba_init_verbs[] = {
15868	{0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15869
15870	{ }
15871};
15872
15873/* toggle speaker-output according to the hp-jack state */
15874static void alc861_toshiba_automute(struct hda_codec *codec)
15875{
15876	unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15877
15878	snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15879				 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15880	snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15881				 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15882}
15883
15884static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15885				       unsigned int res)
15886{
15887	if ((res >> 26) == ALC880_HP_EVENT)
15888		alc861_toshiba_automute(codec);
15889}
15890
15891/* pcm configuration: identical with ALC880 */
15892#define alc861_pcm_analog_playback	alc880_pcm_analog_playback
15893#define alc861_pcm_analog_capture	alc880_pcm_analog_capture
15894#define alc861_pcm_digital_playback	alc880_pcm_digital_playback
15895#define alc861_pcm_digital_capture	alc880_pcm_digital_capture
15896
15897
15898#define ALC861_DIGOUT_NID	0x07
15899
15900static struct hda_channel_mode alc861_8ch_modes[1] = {
15901	{ 8, NULL }
15902};
15903
15904static hda_nid_t alc861_dac_nids[4] = {
15905	/* front, surround, clfe, side */
15906	0x03, 0x06, 0x05, 0x04
15907};
15908
15909static hda_nid_t alc660_dac_nids[3] = {
15910	/* front, clfe, surround */
15911	0x03, 0x05, 0x06
15912};
15913
15914static hda_nid_t alc861_adc_nids[1] = {
15915	/* ADC0-2 */
15916	0x08,
15917};
15918
15919static struct hda_input_mux alc861_capture_source = {
15920	.num_items = 5,
15921	.items = {
15922		{ "Mic", 0x0 },
15923		{ "Front Mic", 0x3 },
15924		{ "Line", 0x1 },
15925		{ "CD", 0x4 },
15926		{ "Mixer", 0x5 },
15927	},
15928};
15929
15930static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15931{
15932	struct alc_spec *spec = codec->spec;
15933	hda_nid_t mix, srcs[5];
15934	int i, j, num;
15935
15936	if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15937		return 0;
15938	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15939	if (num < 0)
15940		return 0;
15941	for (i = 0; i < num; i++) {
15942		unsigned int type;
15943		type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15944		if (type != AC_WID_AUD_OUT)
15945			continue;
15946		for (j = 0; j < spec->multiout.num_dacs; j++)
15947			if (spec->multiout.dac_nids[j] == srcs[i])
15948				break;
15949		if (j >= spec->multiout.num_dacs)
15950			return srcs[i];
15951	}
15952	return 0;
15953}
15954
15955/* fill in the dac_nids table from the parsed pin configuration */
15956static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15957				     const struct auto_pin_cfg *cfg)
15958{
15959	struct alc_spec *spec = codec->spec;
15960	int i;
15961	hda_nid_t nid, dac;
15962
15963	spec->multiout.dac_nids = spec->private_dac_nids;
15964	for (i = 0; i < cfg->line_outs; i++) {
15965		nid = cfg->line_out_pins[i];
15966		dac = alc861_look_for_dac(codec, nid);
15967		if (!dac)
15968			continue;
15969		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15970	}
15971	return 0;
15972}
15973
15974static int __alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15975				  hda_nid_t nid, int idx, unsigned int chs)
15976{
15977	return __add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
15978			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15979}
15980
15981#define alc861_create_out_sw(codec, pfx, nid, chs) \
15982	__alc861_create_out_sw(codec, pfx, nid, 0, chs)
15983
15984/* add playback controls from the parsed DAC table */
15985static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15986					     const struct auto_pin_cfg *cfg)
15987{
15988	struct alc_spec *spec = codec->spec;
15989	static const char * const chname[4] = {
15990		"Front", "Surround", NULL /*CLFE*/, "Side"
15991	};
15992	const char *pfx = alc_get_line_out_pfx(cfg, true);
15993	hda_nid_t nid;
15994	int i, err;
15995
15996	for (i = 0; i < cfg->line_outs; i++) {
15997		nid = spec->multiout.dac_nids[i];
15998		if (!nid)
15999			continue;
16000		if (!pfx && i == 2) {
16001			/* Center/LFE */
16002			err = alc861_create_out_sw(codec, "Center", nid, 1);
16003			if (err < 0)
16004				return err;
16005			err = alc861_create_out_sw(codec, "LFE", nid, 2);
16006			if (err < 0)
16007				return err;
16008		} else {
16009			const char *name = pfx;
16010			if (!name)
16011				name = chname[i];
16012			err = __alc861_create_out_sw(codec, name, nid, i, 3);
16013			if (err < 0)
16014				return err;
16015		}
16016	}
16017	return 0;
16018}
16019
16020static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
16021{
16022	struct alc_spec *spec = codec->spec;
16023	int err;
16024	hda_nid_t nid;
16025
16026	if (!pin)
16027		return 0;
16028
16029	if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
16030		nid = alc861_look_for_dac(codec, pin);
16031		if (nid) {
16032			err = alc861_create_out_sw(codec, "Headphone", nid, 3);
16033			if (err < 0)
16034				return err;
16035			spec->multiout.hp_nid = nid;
16036		}
16037	}
16038	return 0;
16039}
16040
16041/* create playback/capture controls for input pins */
16042static int alc861_auto_create_input_ctls(struct hda_codec *codec,
16043						const struct auto_pin_cfg *cfg)
16044{
16045	return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
16046}
16047
16048static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
16049					      hda_nid_t nid,
16050					      int pin_type, hda_nid_t dac)
16051{
16052	hda_nid_t mix, srcs[5];
16053	int i, num;
16054
16055	snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
16056			    pin_type);
16057	snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16058			    AMP_OUT_UNMUTE);
16059	if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
16060		return;
16061	num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
16062	if (num < 0)
16063		return;
16064	for (i = 0; i < num; i++) {
16065		unsigned int mute;
16066		if (srcs[i] == dac || srcs[i] == 0x15)
16067			mute = AMP_IN_UNMUTE(i);
16068		else
16069			mute = AMP_IN_MUTE(i);
16070		snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16071				    mute);
16072	}
16073}
16074
16075static void alc861_auto_init_multi_out(struct hda_codec *codec)
16076{
16077	struct alc_spec *spec = codec->spec;
16078	int i;
16079
16080	for (i = 0; i < spec->autocfg.line_outs; i++) {
16081		hda_nid_t nid = spec->autocfg.line_out_pins[i];
16082		int pin_type = get_pin_type(spec->autocfg.line_out_type);
16083		if (nid)
16084			alc861_auto_set_output_and_unmute(codec, nid, pin_type,
16085							  spec->multiout.dac_nids[i]);
16086	}
16087}
16088
16089static void alc861_auto_init_hp_out(struct hda_codec *codec)
16090{
16091	struct alc_spec *spec = codec->spec;
16092
16093	if (spec->autocfg.hp_outs)
16094		alc861_auto_set_output_and_unmute(codec,
16095						  spec->autocfg.hp_pins[0],
16096						  PIN_HP,
16097						  spec->multiout.hp_nid);
16098	if (spec->autocfg.speaker_outs)
16099		alc861_auto_set_output_and_unmute(codec,
16100						  spec->autocfg.speaker_pins[0],
16101						  PIN_OUT,
16102						  spec->multiout.dac_nids[0]);
16103}
16104
16105static void alc861_auto_init_analog_input(struct hda_codec *codec)
16106{
16107	struct alc_spec *spec = codec->spec;
16108	struct auto_pin_cfg *cfg = &spec->autocfg;
16109	int i;
16110
16111	for (i = 0; i < cfg->num_inputs; i++) {
16112		hda_nid_t nid = cfg->inputs[i].pin;
16113		if (nid >= 0x0c && nid <= 0x11)
16114			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
16115	}
16116}
16117
16118/* parse the BIOS configuration and set up the alc_spec */
16119/* return 1 if successful, 0 if the proper config is not found,
16120 * or a negative error code
16121 */
16122static int alc861_parse_auto_config(struct hda_codec *codec)
16123{
16124	struct alc_spec *spec = codec->spec;
16125	int err;
16126	static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
16127
16128	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16129					   alc861_ignore);
16130	if (err < 0)
16131		return err;
16132	if (!spec->autocfg.line_outs)
16133		return 0; /* can't find valid BIOS pin config */
16134
16135	err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
16136	if (err < 0)
16137		return err;
16138	err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
16139	if (err < 0)
16140		return err;
16141	err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
16142	if (err < 0)
16143		return err;
16144	err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
16145	if (err < 0)
16146		return err;
16147
16148	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16149
16150	alc_auto_parse_digital(codec);
16151
16152	if (spec->kctls.list)
16153		add_mixer(spec, spec->kctls.list);
16154
16155	add_verb(spec, alc861_auto_init_verbs);
16156
16157	spec->num_mux_defs = 1;
16158	spec->input_mux = &spec->private_imux[0];
16159
16160	spec->adc_nids = alc861_adc_nids;
16161	spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
16162	set_capture_mixer(codec);
16163
16164	alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
16165
16166	return 1;
16167}
16168
16169/* additional initialization for auto-configuration model */
16170static void alc861_auto_init(struct hda_codec *codec)
16171{
16172	struct alc_spec *spec = codec->spec;
16173	alc861_auto_init_multi_out(codec);
16174	alc861_auto_init_hp_out(codec);
16175	alc861_auto_init_analog_input(codec);
16176	alc_auto_init_digital(codec);
16177	if (spec->unsol_event)
16178		alc_inithook(codec);
16179}
16180
16181#ifdef CONFIG_SND_HDA_POWER_SAVE
16182static struct hda_amp_list alc861_loopbacks[] = {
16183	{ 0x15, HDA_INPUT, 0 },
16184	{ 0x15, HDA_INPUT, 1 },
16185	{ 0x15, HDA_INPUT, 2 },
16186	{ 0x15, HDA_INPUT, 3 },
16187	{ } /* end */
16188};
16189#endif
16190
16191
16192/*
16193 * configuration and preset
16194 */
16195static const char * const alc861_models[ALC861_MODEL_LAST] = {
16196	[ALC861_3ST]		= "3stack",
16197	[ALC660_3ST]		= "3stack-660",
16198	[ALC861_3ST_DIG]	= "3stack-dig",
16199	[ALC861_6ST_DIG]	= "6stack-dig",
16200	[ALC861_UNIWILL_M31]	= "uniwill-m31",
16201	[ALC861_TOSHIBA]	= "toshiba",
16202	[ALC861_ASUS]		= "asus",
16203	[ALC861_ASUS_LAPTOP]	= "asus-laptop",
16204	[ALC861_AUTO]		= "auto",
16205};
16206
16207static struct snd_pci_quirk alc861_cfg_tbl[] = {
16208	SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
16209	SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16210	SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
16211	SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
16212	SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
16213	SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
16214	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
16215	/* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
16216	 *        Any other models that need this preset?
16217	 */
16218	/* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
16219	SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
16220	SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
16221	SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
16222	SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
16223	SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
16224	/* FIXME: the below seems conflict */
16225	/* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
16226	SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
16227	SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
16228	{}
16229};
16230
16231static struct alc_config_preset alc861_presets[] = {
16232	[ALC861_3ST] = {
16233		.mixers = { alc861_3ST_mixer },
16234		.init_verbs = { alc861_threestack_init_verbs },
16235		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16236		.dac_nids = alc861_dac_nids,
16237		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16238		.channel_mode = alc861_threestack_modes,
16239		.need_dac_fix = 1,
16240		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16241		.adc_nids = alc861_adc_nids,
16242		.input_mux = &alc861_capture_source,
16243	},
16244	[ALC861_3ST_DIG] = {
16245		.mixers = { alc861_base_mixer },
16246		.init_verbs = { alc861_threestack_init_verbs },
16247		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16248		.dac_nids = alc861_dac_nids,
16249		.dig_out_nid = ALC861_DIGOUT_NID,
16250		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16251		.channel_mode = alc861_threestack_modes,
16252		.need_dac_fix = 1,
16253		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16254		.adc_nids = alc861_adc_nids,
16255		.input_mux = &alc861_capture_source,
16256	},
16257	[ALC861_6ST_DIG] = {
16258		.mixers = { alc861_base_mixer },
16259		.init_verbs = { alc861_base_init_verbs },
16260		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16261		.dac_nids = alc861_dac_nids,
16262		.dig_out_nid = ALC861_DIGOUT_NID,
16263		.num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
16264		.channel_mode = alc861_8ch_modes,
16265		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16266		.adc_nids = alc861_adc_nids,
16267		.input_mux = &alc861_capture_source,
16268	},
16269	[ALC660_3ST] = {
16270		.mixers = { alc861_3ST_mixer },
16271		.init_verbs = { alc861_threestack_init_verbs },
16272		.num_dacs = ARRAY_SIZE(alc660_dac_nids),
16273		.dac_nids = alc660_dac_nids,
16274		.num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
16275		.channel_mode = alc861_threestack_modes,
16276		.need_dac_fix = 1,
16277		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16278		.adc_nids = alc861_adc_nids,
16279		.input_mux = &alc861_capture_source,
16280	},
16281	[ALC861_UNIWILL_M31] = {
16282		.mixers = { alc861_uniwill_m31_mixer },
16283		.init_verbs = { alc861_uniwill_m31_init_verbs },
16284		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16285		.dac_nids = alc861_dac_nids,
16286		.dig_out_nid = ALC861_DIGOUT_NID,
16287		.num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
16288		.channel_mode = alc861_uniwill_m31_modes,
16289		.need_dac_fix = 1,
16290		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16291		.adc_nids = alc861_adc_nids,
16292		.input_mux = &alc861_capture_source,
16293	},
16294	[ALC861_TOSHIBA] = {
16295		.mixers = { alc861_toshiba_mixer },
16296		.init_verbs = { alc861_base_init_verbs,
16297				alc861_toshiba_init_verbs },
16298		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16299		.dac_nids = alc861_dac_nids,
16300		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16301		.channel_mode = alc883_3ST_2ch_modes,
16302		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16303		.adc_nids = alc861_adc_nids,
16304		.input_mux = &alc861_capture_source,
16305		.unsol_event = alc861_toshiba_unsol_event,
16306		.init_hook = alc861_toshiba_automute,
16307	},
16308	[ALC861_ASUS] = {
16309		.mixers = { alc861_asus_mixer },
16310		.init_verbs = { alc861_asus_init_verbs },
16311		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16312		.dac_nids = alc861_dac_nids,
16313		.dig_out_nid = ALC861_DIGOUT_NID,
16314		.num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
16315		.channel_mode = alc861_asus_modes,
16316		.need_dac_fix = 1,
16317		.hp_nid = 0x06,
16318		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16319		.adc_nids = alc861_adc_nids,
16320		.input_mux = &alc861_capture_source,
16321	},
16322	[ALC861_ASUS_LAPTOP] = {
16323		.mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
16324		.init_verbs = { alc861_asus_init_verbs,
16325				alc861_asus_laptop_init_verbs },
16326		.num_dacs = ARRAY_SIZE(alc861_dac_nids),
16327		.dac_nids = alc861_dac_nids,
16328		.dig_out_nid = ALC861_DIGOUT_NID,
16329		.num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
16330		.channel_mode = alc883_3ST_2ch_modes,
16331		.need_dac_fix = 1,
16332		.num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
16333		.adc_nids = alc861_adc_nids,
16334		.input_mux = &alc861_capture_source,
16335	},
16336};
16337
16338/* Pin config fixes */
16339enum {
16340	PINFIX_FSC_AMILO_PI1505,
16341};
16342
16343static const struct alc_fixup alc861_fixups[] = {
16344	[PINFIX_FSC_AMILO_PI1505] = {
16345		.type = ALC_FIXUP_PINS,
16346		.v.pins = (const struct alc_pincfg[]) {
16347			{ 0x0b, 0x0221101f }, /* HP */
16348			{ 0x0f, 0x90170310 }, /* speaker */
16349			{ }
16350		}
16351	},
16352};
16353
16354static struct snd_pci_quirk alc861_fixup_tbl[] = {
16355	SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
16356	{}
16357};
16358
16359static int patch_alc861(struct hda_codec *codec)
16360{
16361	struct alc_spec *spec;
16362	int board_config;
16363	int err;
16364
16365	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16366	if (spec == NULL)
16367		return -ENOMEM;
16368
16369	codec->spec = spec;
16370
16371        board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
16372						  alc861_models,
16373						  alc861_cfg_tbl);
16374
16375	if (board_config < 0) {
16376		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16377		       codec->chip_name);
16378		board_config = ALC861_AUTO;
16379	}
16380
16381	if (board_config == ALC861_AUTO) {
16382		alc_pick_fixup(codec, NULL, alc861_fixup_tbl, alc861_fixups);
16383		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
16384	}
16385
16386	if (board_config == ALC861_AUTO) {
16387		/* automatic parse from the BIOS config */
16388		err = alc861_parse_auto_config(codec);
16389		if (err < 0) {
16390			alc_free(codec);
16391			return err;
16392		} else if (!err) {
16393			printk(KERN_INFO
16394			       "hda_codec: Cannot set up configuration "
16395			       "from BIOS.  Using base mode...\n");
16396		   board_config = ALC861_3ST_DIG;
16397		}
16398	}
16399
16400	err = snd_hda_attach_beep_device(codec, 0x23);
16401	if (err < 0) {
16402		alc_free(codec);
16403		return err;
16404	}
16405
16406	if (board_config != ALC861_AUTO)
16407		setup_preset(codec, &alc861_presets[board_config]);
16408
16409	spec->stream_analog_playback = &alc861_pcm_analog_playback;
16410	spec->stream_analog_capture = &alc861_pcm_analog_capture;
16411
16412	spec->stream_digital_playback = &alc861_pcm_digital_playback;
16413	spec->stream_digital_capture = &alc861_pcm_digital_capture;
16414
16415	if (!spec->cap_mixer)
16416		set_capture_mixer(codec);
16417	set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
16418
16419	spec->vmaster_nid = 0x03;
16420
16421	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
16422
16423	codec->patch_ops = alc_patch_ops;
16424	if (board_config == ALC861_AUTO) {
16425		spec->init_hook = alc861_auto_init;
16426#ifdef CONFIG_SND_HDA_POWER_SAVE
16427		spec->power_hook = alc_power_eapd;
16428#endif
16429	}
16430#ifdef CONFIG_SND_HDA_POWER_SAVE
16431	if (!spec->loopback.amplist)
16432		spec->loopback.amplist = alc861_loopbacks;
16433#endif
16434
16435	return 0;
16436}
16437
16438/*
16439 * ALC861-VD support
16440 *
16441 * Based on ALC882
16442 *
16443 * In addition, an independent DAC
16444 */
16445#define ALC861VD_DIGOUT_NID	0x06
16446
16447static hda_nid_t alc861vd_dac_nids[4] = {
16448	/* front, surr, clfe, side surr */
16449	0x02, 0x03, 0x04, 0x05
16450};
16451
16452/* dac_nids for ALC660vd are in a different order - according to
16453 * Realtek's driver.
16454 * This should probably result in a different mixer for 6stack models
16455 * of ALC660vd codecs, but for now there is only 3stack mixer
16456 * - and it is the same as in 861vd.
16457 * adc_nids in ALC660vd are (is) the same as in 861vd
16458 */
16459static hda_nid_t alc660vd_dac_nids[3] = {
16460	/* front, rear, clfe, rear_surr */
16461	0x02, 0x04, 0x03
16462};
16463
16464static hda_nid_t alc861vd_adc_nids[1] = {
16465	/* ADC0 */
16466	0x09,
16467};
16468
16469static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
16470
16471/* input MUX */
16472/* FIXME: should be a matrix-type input source selection */
16473static struct hda_input_mux alc861vd_capture_source = {
16474	.num_items = 4,
16475	.items = {
16476		{ "Mic", 0x0 },
16477		{ "Front Mic", 0x1 },
16478		{ "Line", 0x2 },
16479		{ "CD", 0x4 },
16480	},
16481};
16482
16483static struct hda_input_mux alc861vd_dallas_capture_source = {
16484	.num_items = 2,
16485	.items = {
16486		{ "Mic", 0x0 },
16487		{ "Internal Mic", 0x1 },
16488	},
16489};
16490
16491static struct hda_input_mux alc861vd_hp_capture_source = {
16492	.num_items = 2,
16493	.items = {
16494		{ "Front Mic", 0x0 },
16495		{ "ATAPI Mic", 0x1 },
16496	},
16497};
16498
16499/*
16500 * 2ch mode
16501 */
16502static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
16503	{ 2, NULL }
16504};
16505
16506/*
16507 * 6ch mode
16508 */
16509static struct hda_verb alc861vd_6stack_ch6_init[] = {
16510	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16511	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16512	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16513	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16514	{ } /* end */
16515};
16516
16517/*
16518 * 8ch mode
16519 */
16520static struct hda_verb alc861vd_6stack_ch8_init[] = {
16521	{ 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16522	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16523	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16524	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16525	{ } /* end */
16526};
16527
16528static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16529	{ 6, alc861vd_6stack_ch6_init },
16530	{ 8, alc861vd_6stack_ch8_init },
16531};
16532
16533static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16534	{
16535		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16536		.name = "Channel Mode",
16537		.info = alc_ch_mode_info,
16538		.get = alc_ch_mode_get,
16539		.put = alc_ch_mode_put,
16540	},
16541	{ } /* end */
16542};
16543
16544/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16545 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16546 */
16547static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16548	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16549	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16550
16551	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16552	HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16553
16554	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16555				HDA_OUTPUT),
16556	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16557				HDA_OUTPUT),
16558	HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16559	HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16560
16561	HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16562	HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16563
16564	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16565
16566	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16567	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16568	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16569
16570	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16571	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16572	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16573
16574	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16575	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16576
16577	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16578	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16579
16580	{ } /* end */
16581};
16582
16583static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16584	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16585	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16586
16587	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16588
16589	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16590	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16591	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16592
16593	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16594	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16595	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16596
16597	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16598	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16599
16600	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16601	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16602
16603	{ } /* end */
16604};
16605
16606static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16607	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16608	/*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16609	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16610
16611	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16612
16613	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16614	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16615	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16616
16617	HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x19, 0, HDA_INPUT),
16618	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16619	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16620
16621	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16622	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16623
16624	{ } /* end */
16625};
16626
16627/* Pin assignment: Speaker=0x14, HP = 0x15,
16628 *                 Mic=0x18, Internal Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16629 */
16630static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16631	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16632	HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16633	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16634	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16635	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
16636	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16637	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16638	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
16639	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16640	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16641	{ } /* end */
16642};
16643
16644/* Pin assignment: Speaker=0x14, Line-out = 0x15,
16645 *                 Front Mic=0x18, ATAPI Mic = 0x19,
16646 */
16647static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16648	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16649	HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16650	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16651	HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16652	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16653	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16654	HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16655	HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16656
16657	{ } /* end */
16658};
16659
16660/*
16661 * generic initialization of ADC, input mixers and output mixers
16662 */
16663static struct hda_verb alc861vd_volume_init_verbs[] = {
16664	/*
16665	 * Unmute ADC0 and set the default input to mic-in
16666	 */
16667	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16668	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16669
16670	/* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16671	 * the analog-loopback mixer widget
16672	 */
16673	/* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16674	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16675	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16676	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16677	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16678	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16679
16680	/* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16681	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16682	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16683	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16684	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16685
16686	/*
16687	 * Set up output mixers (0x02 - 0x05)
16688	 */
16689	/* set vol=0 to output mixers */
16690	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16691	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16692	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16693	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16694
16695	/* set up input amps for analog loopback */
16696	/* Amp Indices: DAC = 0, mixer = 1 */
16697	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16698	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16699	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16700	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16701	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16702	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16703	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16704	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16705
16706	{ }
16707};
16708
16709/*
16710 * 3-stack pin configuration:
16711 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16712 */
16713static struct hda_verb alc861vd_3stack_init_verbs[] = {
16714	/*
16715	 * Set pin mode and muting
16716	 */
16717	/* set front pin widgets 0x14 for output */
16718	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16719	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16720	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16721
16722	/* Mic (rear) pin: input vref at 80% */
16723	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16724	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16725	/* Front Mic pin: input vref at 80% */
16726	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16727	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16728	/* Line In pin: input */
16729	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16730	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16731	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16732	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16733	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16734	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16735	/* CD pin widget for input */
16736	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16737
16738	{ }
16739};
16740
16741/*
16742 * 6-stack pin configuration:
16743 */
16744static struct hda_verb alc861vd_6stack_init_verbs[] = {
16745	/*
16746	 * Set pin mode and muting
16747	 */
16748	/* set front pin widgets 0x14 for output */
16749	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16750	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16751	{0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16752
16753	/* Rear Pin: output 1 (0x0d) */
16754	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16755	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16756	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16757	/* CLFE Pin: output 2 (0x0e) */
16758	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16759	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16760	{0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16761	/* Side Pin: output 3 (0x0f) */
16762	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16763	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16764	{0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16765
16766	/* Mic (rear) pin: input vref at 80% */
16767	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16768	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16769	/* Front Mic pin: input vref at 80% */
16770	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16771	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16772	/* Line In pin: input */
16773	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16774	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16775	/* Line-2 In: Headphone output (output 0 - 0x0c) */
16776	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16777	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16778	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16779	/* CD pin widget for input */
16780	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16781
16782	{ }
16783};
16784
16785static struct hda_verb alc861vd_eapd_verbs[] = {
16786	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16787	{ }
16788};
16789
16790static struct hda_verb alc660vd_eapd_verbs[] = {
16791	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16792	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16793	{ }
16794};
16795
16796static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16797	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16798	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16799	{0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16800	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16801	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16802	{}
16803};
16804
16805static void alc861vd_lenovo_setup(struct hda_codec *codec)
16806{
16807	struct alc_spec *spec = codec->spec;
16808	spec->autocfg.hp_pins[0] = 0x1b;
16809	spec->autocfg.speaker_pins[0] = 0x14;
16810}
16811
16812static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16813{
16814	alc_automute_amp(codec);
16815	alc88x_simple_mic_automute(codec);
16816}
16817
16818static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16819					unsigned int res)
16820{
16821	switch (res >> 26) {
16822	case ALC880_MIC_EVENT:
16823		alc88x_simple_mic_automute(codec);
16824		break;
16825	default:
16826		alc_automute_amp_unsol_event(codec, res);
16827		break;
16828	}
16829}
16830
16831static struct hda_verb alc861vd_dallas_verbs[] = {
16832	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16833	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16834	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16835	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16836
16837	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16838	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16839	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16840	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16841	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16842	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16843	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16844	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16845
16846	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16847	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16848	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16849	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16850	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16851	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16852	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16853	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16854
16855	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16856	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16857	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16858	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16859	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16860	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16861	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16862	{0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16863
16864	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16865	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16866	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16867	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16868
16869	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16870	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16871	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16872
16873	{ } /* end */
16874};
16875
16876/* toggle speaker-output according to the hp-jack state */
16877static void alc861vd_dallas_setup(struct hda_codec *codec)
16878{
16879	struct alc_spec *spec = codec->spec;
16880
16881	spec->autocfg.hp_pins[0] = 0x15;
16882	spec->autocfg.speaker_pins[0] = 0x14;
16883}
16884
16885#ifdef CONFIG_SND_HDA_POWER_SAVE
16886#define alc861vd_loopbacks	alc880_loopbacks
16887#endif
16888
16889/* pcm configuration: identical with ALC880 */
16890#define alc861vd_pcm_analog_playback	alc880_pcm_analog_playback
16891#define alc861vd_pcm_analog_capture	alc880_pcm_analog_capture
16892#define alc861vd_pcm_digital_playback	alc880_pcm_digital_playback
16893#define alc861vd_pcm_digital_capture	alc880_pcm_digital_capture
16894
16895/*
16896 * configuration and preset
16897 */
16898static const char * const alc861vd_models[ALC861VD_MODEL_LAST] = {
16899	[ALC660VD_3ST]		= "3stack-660",
16900	[ALC660VD_3ST_DIG]	= "3stack-660-digout",
16901	[ALC660VD_ASUS_V1S]	= "asus-v1s",
16902	[ALC861VD_3ST]		= "3stack",
16903	[ALC861VD_3ST_DIG]	= "3stack-digout",
16904	[ALC861VD_6ST_DIG]	= "6stack-digout",
16905	[ALC861VD_LENOVO]	= "lenovo",
16906	[ALC861VD_DALLAS]	= "dallas",
16907	[ALC861VD_HP]		= "hp",
16908	[ALC861VD_AUTO]		= "auto",
16909};
16910
16911static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16912	SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16913	SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16914	SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16915	/*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16916	SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16917	SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16918	SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16919	SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16920	/*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16921	SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16922	SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16923	SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16924	SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16925	SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16926	SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16927	{}
16928};
16929
16930static struct alc_config_preset alc861vd_presets[] = {
16931	[ALC660VD_3ST] = {
16932		.mixers = { alc861vd_3st_mixer },
16933		.init_verbs = { alc861vd_volume_init_verbs,
16934				 alc861vd_3stack_init_verbs },
16935		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16936		.dac_nids = alc660vd_dac_nids,
16937		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16938		.channel_mode = alc861vd_3stack_2ch_modes,
16939		.input_mux = &alc861vd_capture_source,
16940	},
16941	[ALC660VD_3ST_DIG] = {
16942		.mixers = { alc861vd_3st_mixer },
16943		.init_verbs = { alc861vd_volume_init_verbs,
16944				 alc861vd_3stack_init_verbs },
16945		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16946		.dac_nids = alc660vd_dac_nids,
16947		.dig_out_nid = ALC861VD_DIGOUT_NID,
16948		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16949		.channel_mode = alc861vd_3stack_2ch_modes,
16950		.input_mux = &alc861vd_capture_source,
16951	},
16952	[ALC861VD_3ST] = {
16953		.mixers = { alc861vd_3st_mixer },
16954		.init_verbs = { alc861vd_volume_init_verbs,
16955				 alc861vd_3stack_init_verbs },
16956		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16957		.dac_nids = alc861vd_dac_nids,
16958		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16959		.channel_mode = alc861vd_3stack_2ch_modes,
16960		.input_mux = &alc861vd_capture_source,
16961	},
16962	[ALC861VD_3ST_DIG] = {
16963		.mixers = { alc861vd_3st_mixer },
16964		.init_verbs = { alc861vd_volume_init_verbs,
16965		 		 alc861vd_3stack_init_verbs },
16966		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16967		.dac_nids = alc861vd_dac_nids,
16968		.dig_out_nid = ALC861VD_DIGOUT_NID,
16969		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16970		.channel_mode = alc861vd_3stack_2ch_modes,
16971		.input_mux = &alc861vd_capture_source,
16972	},
16973	[ALC861VD_6ST_DIG] = {
16974		.mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16975		.init_verbs = { alc861vd_volume_init_verbs,
16976				alc861vd_6stack_init_verbs },
16977		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16978		.dac_nids = alc861vd_dac_nids,
16979		.dig_out_nid = ALC861VD_DIGOUT_NID,
16980		.num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16981		.channel_mode = alc861vd_6stack_modes,
16982		.input_mux = &alc861vd_capture_source,
16983	},
16984	[ALC861VD_LENOVO] = {
16985		.mixers = { alc861vd_lenovo_mixer },
16986		.init_verbs = { alc861vd_volume_init_verbs,
16987				alc861vd_3stack_init_verbs,
16988				alc861vd_eapd_verbs,
16989				alc861vd_lenovo_unsol_verbs },
16990		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16991		.dac_nids = alc660vd_dac_nids,
16992		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16993		.channel_mode = alc861vd_3stack_2ch_modes,
16994		.input_mux = &alc861vd_capture_source,
16995		.unsol_event = alc861vd_lenovo_unsol_event,
16996		.setup = alc861vd_lenovo_setup,
16997		.init_hook = alc861vd_lenovo_init_hook,
16998	},
16999	[ALC861VD_DALLAS] = {
17000		.mixers = { alc861vd_dallas_mixer },
17001		.init_verbs = { alc861vd_dallas_verbs },
17002		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17003		.dac_nids = alc861vd_dac_nids,
17004		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17005		.channel_mode = alc861vd_3stack_2ch_modes,
17006		.input_mux = &alc861vd_dallas_capture_source,
17007		.unsol_event = alc_automute_amp_unsol_event,
17008		.setup = alc861vd_dallas_setup,
17009		.init_hook = alc_automute_amp,
17010	},
17011	[ALC861VD_HP] = {
17012		.mixers = { alc861vd_hp_mixer },
17013		.init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
17014		.num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
17015		.dac_nids = alc861vd_dac_nids,
17016		.dig_out_nid = ALC861VD_DIGOUT_NID,
17017		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17018		.channel_mode = alc861vd_3stack_2ch_modes,
17019		.input_mux = &alc861vd_hp_capture_source,
17020		.unsol_event = alc_automute_amp_unsol_event,
17021		.setup = alc861vd_dallas_setup,
17022		.init_hook = alc_automute_amp,
17023	},
17024	[ALC660VD_ASUS_V1S] = {
17025		.mixers = { alc861vd_lenovo_mixer },
17026		.init_verbs = { alc861vd_volume_init_verbs,
17027				alc861vd_3stack_init_verbs,
17028				alc861vd_eapd_verbs,
17029				alc861vd_lenovo_unsol_verbs },
17030		.num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
17031		.dac_nids = alc660vd_dac_nids,
17032		.dig_out_nid = ALC861VD_DIGOUT_NID,
17033		.num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
17034		.channel_mode = alc861vd_3stack_2ch_modes,
17035		.input_mux = &alc861vd_capture_source,
17036		.unsol_event = alc861vd_lenovo_unsol_event,
17037		.setup = alc861vd_lenovo_setup,
17038		.init_hook = alc861vd_lenovo_init_hook,
17039	},
17040};
17041
17042/*
17043 * BIOS auto configuration
17044 */
17045static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
17046						const struct auto_pin_cfg *cfg)
17047{
17048	return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x22, 0);
17049}
17050
17051
17052static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
17053				hda_nid_t nid, int pin_type, int dac_idx)
17054{
17055	alc_set_pin_output(codec, nid, pin_type);
17056}
17057
17058static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
17059{
17060	struct alc_spec *spec = codec->spec;
17061	int i;
17062
17063	for (i = 0; i <= HDA_SIDE; i++) {
17064		hda_nid_t nid = spec->autocfg.line_out_pins[i];
17065		int pin_type = get_pin_type(spec->autocfg.line_out_type);
17066		if (nid)
17067			alc861vd_auto_set_output_and_unmute(codec, nid,
17068							    pin_type, i);
17069	}
17070}
17071
17072
17073static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
17074{
17075	struct alc_spec *spec = codec->spec;
17076	hda_nid_t pin;
17077
17078	pin = spec->autocfg.hp_pins[0];
17079	if (pin) /* connect to front and use dac 0 */
17080		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17081	pin = spec->autocfg.speaker_pins[0];
17082	if (pin)
17083		alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17084}
17085
17086#define ALC861VD_PIN_CD_NID		ALC880_PIN_CD_NID
17087
17088static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
17089{
17090	struct alc_spec *spec = codec->spec;
17091	struct auto_pin_cfg *cfg = &spec->autocfg;
17092	int i;
17093
17094	for (i = 0; i < cfg->num_inputs; i++) {
17095		hda_nid_t nid = cfg->inputs[i].pin;
17096		if (alc_is_input_pin(codec, nid)) {
17097			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
17098			if (nid != ALC861VD_PIN_CD_NID &&
17099			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17100				snd_hda_codec_write(codec, nid, 0,
17101						AC_VERB_SET_AMP_GAIN_MUTE,
17102						AMP_OUT_MUTE);
17103		}
17104	}
17105}
17106
17107#define alc861vd_auto_init_input_src	alc882_auto_init_input_src
17108
17109#define alc861vd_idx_to_mixer_vol(nid)		((nid) + 0x02)
17110#define alc861vd_idx_to_mixer_switch(nid)	((nid) + 0x0c)
17111
17112/* add playback controls from the parsed DAC table */
17113/* Based on ALC880 version. But ALC861VD has separate,
17114 * different NIDs for mute/unmute switch and volume control */
17115static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
17116					     const struct auto_pin_cfg *cfg)
17117{
17118	static const char * const chname[4] = {
17119		"Front", "Surround", "CLFE", "Side"
17120	};
17121	const char *pfx = alc_get_line_out_pfx(cfg, true);
17122	hda_nid_t nid_v, nid_s;
17123	int i, err;
17124
17125	for (i = 0; i < cfg->line_outs; i++) {
17126		if (!spec->multiout.dac_nids[i])
17127			continue;
17128		nid_v = alc861vd_idx_to_mixer_vol(
17129				alc880_dac_to_idx(
17130					spec->multiout.dac_nids[i]));
17131		nid_s = alc861vd_idx_to_mixer_switch(
17132				alc880_dac_to_idx(
17133					spec->multiout.dac_nids[i]));
17134
17135		if (!pfx && i == 2) {
17136			/* Center/LFE */
17137			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17138					      "Center",
17139					  HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
17140							      HDA_OUTPUT));
17141			if (err < 0)
17142				return err;
17143			err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17144					      "LFE",
17145					  HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
17146							      HDA_OUTPUT));
17147			if (err < 0)
17148				return err;
17149			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17150					     "Center",
17151					  HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
17152							      HDA_INPUT));
17153			if (err < 0)
17154				return err;
17155			err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17156					     "LFE",
17157					  HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
17158							      HDA_INPUT));
17159			if (err < 0)
17160				return err;
17161		} else {
17162			const char *name = pfx;
17163			if (!name)
17164				name = chname[i];
17165			err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
17166						name, i,
17167					  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
17168							      HDA_OUTPUT));
17169			if (err < 0)
17170				return err;
17171			err = __add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
17172					       name, i,
17173					  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
17174							      HDA_INPUT));
17175			if (err < 0)
17176				return err;
17177		}
17178	}
17179	return 0;
17180}
17181
17182/* add playback controls for speaker and HP outputs */
17183/* Based on ALC880 version. But ALC861VD has separate,
17184 * different NIDs for mute/unmute switch and volume control */
17185static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
17186					hda_nid_t pin, const char *pfx)
17187{
17188	hda_nid_t nid_v, nid_s;
17189	int err;
17190
17191	if (!pin)
17192		return 0;
17193
17194	if (alc880_is_fixed_pin(pin)) {
17195		nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17196		/* specify the DAC as the extra output */
17197		if (!spec->multiout.hp_nid)
17198			spec->multiout.hp_nid = nid_v;
17199		else
17200			spec->multiout.extra_out_nid[0] = nid_v;
17201		/* control HP volume/switch on the output mixer amp */
17202		nid_v = alc861vd_idx_to_mixer_vol(
17203				alc880_fixed_pin_idx(pin));
17204		nid_s = alc861vd_idx_to_mixer_switch(
17205				alc880_fixed_pin_idx(pin));
17206
17207		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17208				  HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
17209		if (err < 0)
17210			return err;
17211		err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
17212				  HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
17213		if (err < 0)
17214			return err;
17215	} else if (alc880_is_multi_pin(pin)) {
17216		/* set manual connection */
17217		/* we have only a switch on HP-out PIN */
17218		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17219				  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17220		if (err < 0)
17221			return err;
17222	}
17223	return 0;
17224}
17225
17226/* parse the BIOS configuration and set up the alc_spec
17227 * return 1 if successful, 0 if the proper config is not found,
17228 * or a negative error code
17229 * Based on ALC880 version - had to change it to override
17230 * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
17231static int alc861vd_parse_auto_config(struct hda_codec *codec)
17232{
17233	struct alc_spec *spec = codec->spec;
17234	int err;
17235	static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
17236
17237	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17238					   alc861vd_ignore);
17239	if (err < 0)
17240		return err;
17241	if (!spec->autocfg.line_outs)
17242		return 0; /* can't find valid BIOS pin config */
17243
17244	err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17245	if (err < 0)
17246		return err;
17247	err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
17248	if (err < 0)
17249		return err;
17250	err = alc861vd_auto_create_extra_out(spec,
17251					     spec->autocfg.speaker_pins[0],
17252					     "Speaker");
17253	if (err < 0)
17254		return err;
17255	err = alc861vd_auto_create_extra_out(spec,
17256					     spec->autocfg.hp_pins[0],
17257					     "Headphone");
17258	if (err < 0)
17259		return err;
17260	err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
17261	if (err < 0)
17262		return err;
17263
17264	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17265
17266	alc_auto_parse_digital(codec);
17267
17268	if (spec->kctls.list)
17269		add_mixer(spec, spec->kctls.list);
17270
17271	add_verb(spec, alc861vd_volume_init_verbs);
17272
17273	spec->num_mux_defs = 1;
17274	spec->input_mux = &spec->private_imux[0];
17275
17276	err = alc_auto_add_mic_boost(codec);
17277	if (err < 0)
17278		return err;
17279
17280	alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
17281
17282	return 1;
17283}
17284
17285/* additional initialization for auto-configuration model */
17286static void alc861vd_auto_init(struct hda_codec *codec)
17287{
17288	struct alc_spec *spec = codec->spec;
17289	alc861vd_auto_init_multi_out(codec);
17290	alc861vd_auto_init_hp_out(codec);
17291	alc861vd_auto_init_analog_input(codec);
17292	alc861vd_auto_init_input_src(codec);
17293	alc_auto_init_digital(codec);
17294	if (spec->unsol_event)
17295		alc_inithook(codec);
17296}
17297
17298enum {
17299	ALC660VD_FIX_ASUS_GPIO1
17300};
17301
17302/* reset GPIO1 */
17303static const struct alc_fixup alc861vd_fixups[] = {
17304	[ALC660VD_FIX_ASUS_GPIO1] = {
17305		.type = ALC_FIXUP_VERBS,
17306		.v.verbs = (const struct hda_verb[]) {
17307			{0x01, AC_VERB_SET_GPIO_MASK, 0x03},
17308			{0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
17309			{0x01, AC_VERB_SET_GPIO_DATA, 0x01},
17310			{ }
17311		}
17312	},
17313};
17314
17315static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
17316	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
17317	{}
17318};
17319
17320static int patch_alc861vd(struct hda_codec *codec)
17321{
17322	struct alc_spec *spec;
17323	int err, board_config;
17324
17325	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17326	if (spec == NULL)
17327		return -ENOMEM;
17328
17329	codec->spec = spec;
17330
17331	board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
17332						  alc861vd_models,
17333						  alc861vd_cfg_tbl);
17334
17335	if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
17336		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17337		       codec->chip_name);
17338		board_config = ALC861VD_AUTO;
17339	}
17340
17341	if (board_config == ALC861VD_AUTO) {
17342		alc_pick_fixup(codec, NULL, alc861vd_fixup_tbl, alc861vd_fixups);
17343		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
17344	}
17345
17346	if (board_config == ALC861VD_AUTO) {
17347		/* automatic parse from the BIOS config */
17348		err = alc861vd_parse_auto_config(codec);
17349		if (err < 0) {
17350			alc_free(codec);
17351			return err;
17352		} else if (!err) {
17353			printk(KERN_INFO
17354			       "hda_codec: Cannot set up configuration "
17355			       "from BIOS.  Using base mode...\n");
17356			board_config = ALC861VD_3ST;
17357		}
17358	}
17359
17360	err = snd_hda_attach_beep_device(codec, 0x23);
17361	if (err < 0) {
17362		alc_free(codec);
17363		return err;
17364	}
17365
17366	if (board_config != ALC861VD_AUTO)
17367		setup_preset(codec, &alc861vd_presets[board_config]);
17368
17369	if (codec->vendor_id == 0x10ec0660) {
17370		/* always turn on EAPD */
17371		add_verb(spec, alc660vd_eapd_verbs);
17372	}
17373
17374	spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
17375	spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
17376
17377	spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
17378	spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
17379
17380	if (!spec->adc_nids) {
17381		spec->adc_nids = alc861vd_adc_nids;
17382		spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
17383	}
17384	if (!spec->capsrc_nids)
17385		spec->capsrc_nids = alc861vd_capsrc_nids;
17386
17387	set_capture_mixer(codec);
17388	set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17389
17390	spec->vmaster_nid = 0x02;
17391
17392	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
17393
17394	codec->patch_ops = alc_patch_ops;
17395
17396	if (board_config == ALC861VD_AUTO)
17397		spec->init_hook = alc861vd_auto_init;
17398#ifdef CONFIG_SND_HDA_POWER_SAVE
17399	if (!spec->loopback.amplist)
17400		spec->loopback.amplist = alc861vd_loopbacks;
17401#endif
17402
17403	return 0;
17404}
17405
17406/*
17407 * ALC662 support
17408 *
17409 * ALC662 is almost identical with ALC880 but has cleaner and more flexible
17410 * configuration.  Each pin widget can choose any input DACs and a mixer.
17411 * Each ADC is connected from a mixer of all inputs.  This makes possible
17412 * 6-channel independent captures.
17413 *
17414 * In addition, an independent DAC for the multi-playback (not used in this
17415 * driver yet).
17416 */
17417#define ALC662_DIGOUT_NID	0x06
17418#define ALC662_DIGIN_NID	0x0a
17419
17420static hda_nid_t alc662_dac_nids[4] = {
17421	/* front, rear, clfe, rear_surr */
17422	0x02, 0x03, 0x04
17423};
17424
17425static hda_nid_t alc272_dac_nids[2] = {
17426	0x02, 0x03
17427};
17428
17429static hda_nid_t alc662_adc_nids[2] = {
17430	/* ADC1-2 */
17431	0x09, 0x08
17432};
17433
17434static hda_nid_t alc272_adc_nids[1] = {
17435	/* ADC1-2 */
17436	0x08,
17437};
17438
17439static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
17440static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
17441
17442
17443/* input MUX */
17444/* FIXME: should be a matrix-type input source selection */
17445static struct hda_input_mux alc662_capture_source = {
17446	.num_items = 4,
17447	.items = {
17448		{ "Mic", 0x0 },
17449		{ "Front Mic", 0x1 },
17450		{ "Line", 0x2 },
17451		{ "CD", 0x4 },
17452	},
17453};
17454
17455static struct hda_input_mux alc662_lenovo_101e_capture_source = {
17456	.num_items = 2,
17457	.items = {
17458		{ "Mic", 0x1 },
17459		{ "Line", 0x2 },
17460	},
17461};
17462
17463static struct hda_input_mux alc663_capture_source = {
17464	.num_items = 3,
17465	.items = {
17466		{ "Mic", 0x0 },
17467		{ "Front Mic", 0x1 },
17468		{ "Line", 0x2 },
17469	},
17470};
17471
17472#if 0 /* set to 1 for testing other input sources below */
17473static struct hda_input_mux alc272_nc10_capture_source = {
17474	.num_items = 16,
17475	.items = {
17476		{ "Autoselect Mic", 0x0 },
17477		{ "Internal Mic", 0x1 },
17478		{ "In-0x02", 0x2 },
17479		{ "In-0x03", 0x3 },
17480		{ "In-0x04", 0x4 },
17481		{ "In-0x05", 0x5 },
17482		{ "In-0x06", 0x6 },
17483		{ "In-0x07", 0x7 },
17484		{ "In-0x08", 0x8 },
17485		{ "In-0x09", 0x9 },
17486		{ "In-0x0a", 0x0a },
17487		{ "In-0x0b", 0x0b },
17488		{ "In-0x0c", 0x0c },
17489		{ "In-0x0d", 0x0d },
17490		{ "In-0x0e", 0x0e },
17491		{ "In-0x0f", 0x0f },
17492	},
17493};
17494#endif
17495
17496/*
17497 * 2ch mode
17498 */
17499static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17500	{ 2, NULL }
17501};
17502
17503/*
17504 * 2ch mode
17505 */
17506static struct hda_verb alc662_3ST_ch2_init[] = {
17507	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17508	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17509	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17510	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17511	{ } /* end */
17512};
17513
17514/*
17515 * 6ch mode
17516 */
17517static struct hda_verb alc662_3ST_ch6_init[] = {
17518	{ 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17519	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17520	{ 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17521	{ 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17522	{ 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17523	{ 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17524	{ } /* end */
17525};
17526
17527static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17528	{ 2, alc662_3ST_ch2_init },
17529	{ 6, alc662_3ST_ch6_init },
17530};
17531
17532/*
17533 * 2ch mode
17534 */
17535static struct hda_verb alc662_sixstack_ch6_init[] = {
17536	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17537	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17538	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17539	{ } /* end */
17540};
17541
17542/*
17543 * 6ch mode
17544 */
17545static struct hda_verb alc662_sixstack_ch8_init[] = {
17546	{ 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17547	{ 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17548	{ 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17549	{ } /* end */
17550};
17551
17552static struct hda_channel_mode alc662_5stack_modes[2] = {
17553	{ 2, alc662_sixstack_ch6_init },
17554	{ 6, alc662_sixstack_ch8_init },
17555};
17556
17557/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17558 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17559 */
17560
17561static struct snd_kcontrol_new alc662_base_mixer[] = {
17562	/* output mixer control */
17563	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17564	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17565	HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17566	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17567	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17568	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17569	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17570	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17571	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17572
17573	/*Input mixer control */
17574	HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17575	HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17576	HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17577	HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17578	HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17579	HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17580	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17581	HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17582	{ } /* end */
17583};
17584
17585static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17586	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17587	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17588	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17589	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17590	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17591	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17592	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17593	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17594	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17595	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17596	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17597	{ } /* end */
17598};
17599
17600static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17601	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17602	HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17603	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17604	HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17605	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17606	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17607	HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17608	HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17609	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17610	HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17611	HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17612	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17613	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17614	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17615	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17616	HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17617	HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17618	{ } /* end */
17619};
17620
17621static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17622	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17623	HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17624	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17625	HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17626	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17627	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17628	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17629	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17630	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17631	{ } /* end */
17632};
17633
17634static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17635	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17636	ALC262_HIPPO_MASTER_SWITCH,
17637
17638	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
17639	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17640	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17641
17642	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
17643	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17644	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17645	{ } /* end */
17646};
17647
17648static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17649	ALC262_HIPPO_MASTER_SWITCH,
17650	HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17651	HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17652	HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17653	HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17654	HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17655	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17656	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17657	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17658	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17659	{ } /* end */
17660};
17661
17662static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17663	.ops = &snd_hda_bind_vol,
17664	.values = {
17665		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17666		HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17667		0
17668	},
17669};
17670
17671static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17672	.ops = &snd_hda_bind_sw,
17673	.values = {
17674		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17675		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17676		0
17677	},
17678};
17679
17680static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17681	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17682	HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17683	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17684	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17685	{ } /* end */
17686};
17687
17688static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17689	.ops = &snd_hda_bind_sw,
17690	.values = {
17691		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17692		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17693		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17694		0
17695	},
17696};
17697
17698static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17699	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17700	HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17701	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17702	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17703	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17704	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17705
17706	{ } /* end */
17707};
17708
17709static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17710	.ops = &snd_hda_bind_sw,
17711	.values = {
17712		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17713		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17714		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17715		0
17716	},
17717};
17718
17719static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17720	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17721	HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17722	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17723	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17724	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17725	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17726	{ } /* end */
17727};
17728
17729static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17730	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17731	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17732	HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17733	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17734	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17735	HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17736	HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17737	{ } /* end */
17738};
17739
17740static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17741	.ops = &snd_hda_bind_vol,
17742	.values = {
17743		HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17744		HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17745		0
17746	},
17747};
17748
17749static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17750	.ops = &snd_hda_bind_sw,
17751	.values = {
17752		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17753		HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17754		0
17755	},
17756};
17757
17758static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17759	HDA_BIND_VOL("Master Playback Volume",
17760				&alc663_asus_two_bind_master_vol),
17761	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17762	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17763	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17764	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17765	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17766	{ } /* end */
17767};
17768
17769static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17770	HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17771	HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17772	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17773	HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17774	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17775	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17776	{ } /* end */
17777};
17778
17779static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17780	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17781	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17782	HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17783	HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17784	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17785
17786	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17787	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17788	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17789	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17790	{ } /* end */
17791};
17792
17793static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17794	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17795	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17796	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17797
17798	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17799	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17800	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17801	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17802	HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17803	HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17804	{ } /* end */
17805};
17806
17807static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17808	.ops = &snd_hda_bind_sw,
17809	.values = {
17810		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17811		HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17812		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17813		HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17814		HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17815		0
17816	},
17817};
17818
17819static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17820	.ops = &snd_hda_bind_sw,
17821	.values = {
17822		HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17823		HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17824		0
17825	},
17826};
17827
17828static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17829	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17830	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17831	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17832	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17833	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17834	HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17835	HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17836	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17837	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17838	{ } /* end */
17839};
17840
17841static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17842	HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17843	HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17844	HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17845	HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17846	HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17847	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17848	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17849	{ } /* end */
17850};
17851
17852
17853static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17854	{
17855		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17856		.name = "Channel Mode",
17857		.info = alc_ch_mode_info,
17858		.get = alc_ch_mode_get,
17859		.put = alc_ch_mode_put,
17860	},
17861	{ } /* end */
17862};
17863
17864static struct hda_verb alc662_init_verbs[] = {
17865	/* ADC: mute amp left and right */
17866	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17867	{0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17868
17869	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17870	{0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17871	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17872	{0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17873	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17874	{0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17875
17876	/* Front Pin: output 0 (0x0c) */
17877	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17878	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17879
17880	/* Rear Pin: output 1 (0x0d) */
17881	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17882	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17883
17884	/* CLFE Pin: output 2 (0x0e) */
17885	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17886	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17887
17888	/* Mic (rear) pin: input vref at 80% */
17889	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17890	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17891	/* Front Mic pin: input vref at 80% */
17892	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17893	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17894	/* Line In pin: input */
17895	{0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17896	{0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17897	/* Line-2 In: Headphone output (output 0 - 0x0c) */
17898	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17899	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17900	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17901	/* CD pin widget for input */
17902	{0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17903
17904	/* FIXME: use matrix-type input source selection */
17905	/* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17906	/* Input mixer */
17907	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17908	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17909
17910	/* always trun on EAPD */
17911	{0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17912	{0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17913
17914	{ }
17915};
17916
17917static struct hda_verb alc663_init_verbs[] = {
17918	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17919	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17920	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17921	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17922	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17923	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17924	{ }
17925};
17926
17927static struct hda_verb alc272_init_verbs[] = {
17928	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17929	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17930	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17931	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17932	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17933	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17934	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17935	{0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17936	{ }
17937};
17938
17939static struct hda_verb alc662_sue_init_verbs[] = {
17940	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17941	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17942	{}
17943};
17944
17945static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17946	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17947	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17948	{}
17949};
17950
17951/* Set Unsolicited Event*/
17952static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17953	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17954	{0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17955	{}
17956};
17957
17958static struct hda_verb alc663_m51va_init_verbs[] = {
17959	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17960	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17961	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17962	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17963	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17964	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17965	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17966	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17967	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17968	{}
17969};
17970
17971static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17972	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17973	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17974	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17975	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17976	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17977	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17978	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17979	{}
17980};
17981
17982static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17983	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17984	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17985	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17986	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
17987	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17988	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17989	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17990	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17991	{}
17992};
17993
17994static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17995	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17996	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17997	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
17998	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17999	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18000	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18001	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18002	{}
18003};
18004
18005static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
18006	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18007	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18008	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18009	{0x21, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
18010	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18011	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18012	{0x15, AC_VERB_SET_CONNECT_SEL, 0x0},	/* Headphone */
18013	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18014	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18015	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18016	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18017	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18018	{}
18019};
18020
18021static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
18022	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18023	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18024	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18025	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18026	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18027	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18028	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18029	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18030	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
18031	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18032	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18033	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18034	{}
18035};
18036
18037static struct hda_verb alc663_g71v_init_verbs[] = {
18038	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18039	/* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
18040	/* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
18041
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, 0x00},	/* Headphone */
18045
18046	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
18047	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
18048	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
18049	{}
18050};
18051
18052static struct hda_verb alc663_g50v_init_verbs[] = {
18053	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18054	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18055	{0x21, AC_VERB_SET_CONNECT_SEL, 0x00},	/* Headphone */
18056
18057	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18058	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18059	{}
18060};
18061
18062static struct hda_verb alc662_ecs_init_verbs[] = {
18063	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
18064	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18065	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18066	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18067	{}
18068};
18069
18070static struct hda_verb alc272_dell_zm1_init_verbs[] = {
18071	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18072	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18073	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18074	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18075	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18076	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18077	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18078	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18079	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18080	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18081	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18082	{}
18083};
18084
18085static struct hda_verb alc272_dell_init_verbs[] = {
18086	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18087	{0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18088	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18089	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18090	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18091	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18092	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18093	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18094	{0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18095	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18096	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18097	{}
18098};
18099
18100static struct hda_verb alc663_mode7_init_verbs[] = {
18101	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18102	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18103	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18104	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18105	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18106	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18107	{0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
18108	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18109	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18110	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18111	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18112	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18113	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18114	{0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18115	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18116	{}
18117};
18118
18119static struct hda_verb alc663_mode8_init_verbs[] = {
18120	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18121	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18122	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18123	{0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
18124	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18125	{0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
18126	{0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18127	{0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
18128	{0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
18129	{0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
18130	{0x21, AC_VERB_SET_CONNECT_SEL, 0x01},	/* Headphone */
18131	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
18132	{0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
18133	{0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18134	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
18135	{0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
18136	{}
18137};
18138
18139static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
18140	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
18141	HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
18142	{ } /* end */
18143};
18144
18145static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
18146	HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
18147	HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
18148	{ } /* end */
18149};
18150
18151static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
18152{
18153	unsigned int present;
18154	unsigned char bits;
18155
18156	present = snd_hda_jack_detect(codec, 0x14);
18157	bits = present ? HDA_AMP_MUTE : 0;
18158
18159	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18160				 HDA_AMP_MUTE, bits);
18161}
18162
18163static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
18164{
18165	unsigned int present;
18166	unsigned char bits;
18167
18168 	present = snd_hda_jack_detect(codec, 0x1b);
18169	bits = present ? HDA_AMP_MUTE : 0;
18170
18171	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18172				 HDA_AMP_MUTE, bits);
18173	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18174				 HDA_AMP_MUTE, bits);
18175}
18176
18177static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
18178					   unsigned int res)
18179{
18180	if ((res >> 26) == ALC880_HP_EVENT)
18181		alc662_lenovo_101e_all_automute(codec);
18182	if ((res >> 26) == ALC880_FRONT_EVENT)
18183		alc662_lenovo_101e_ispeaker_automute(codec);
18184}
18185
18186/* unsolicited event for HP jack sensing */
18187static void alc662_eeepc_unsol_event(struct hda_codec *codec,
18188				     unsigned int res)
18189{
18190	if ((res >> 26) == ALC880_MIC_EVENT)
18191		alc_mic_automute(codec);
18192	else
18193		alc262_hippo_unsol_event(codec, res);
18194}
18195
18196static void alc662_eeepc_setup(struct hda_codec *codec)
18197{
18198	struct alc_spec *spec = codec->spec;
18199
18200	alc262_hippo1_setup(codec);
18201	spec->ext_mic.pin = 0x18;
18202	spec->ext_mic.mux_idx = 0;
18203	spec->int_mic.pin = 0x19;
18204	spec->int_mic.mux_idx = 1;
18205	spec->auto_mic = 1;
18206}
18207
18208static void alc662_eeepc_inithook(struct hda_codec *codec)
18209{
18210	alc262_hippo_automute(codec);
18211	alc_mic_automute(codec);
18212}
18213
18214static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
18215{
18216	struct alc_spec *spec = codec->spec;
18217
18218	spec->autocfg.hp_pins[0] = 0x14;
18219	spec->autocfg.speaker_pins[0] = 0x1b;
18220}
18221
18222#define alc662_eeepc_ep20_inithook	alc262_hippo_master_update
18223
18224static void alc663_m51va_speaker_automute(struct hda_codec *codec)
18225{
18226	unsigned int present;
18227	unsigned char bits;
18228
18229	present = snd_hda_jack_detect(codec, 0x21);
18230	bits = present ? HDA_AMP_MUTE : 0;
18231	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18232				 HDA_AMP_MUTE, bits);
18233	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18234				 HDA_AMP_MUTE, bits);
18235}
18236
18237static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
18238{
18239	unsigned int present;
18240	unsigned char bits;
18241
18242	present = snd_hda_jack_detect(codec, 0x21);
18243	bits = present ? HDA_AMP_MUTE : 0;
18244	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18245				 HDA_AMP_MUTE, bits);
18246	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18247				 HDA_AMP_MUTE, bits);
18248	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18249				 HDA_AMP_MUTE, bits);
18250	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18251				 HDA_AMP_MUTE, bits);
18252}
18253
18254static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
18255{
18256	unsigned int present;
18257	unsigned char bits;
18258
18259	present = snd_hda_jack_detect(codec, 0x15);
18260	bits = present ? HDA_AMP_MUTE : 0;
18261	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18262				 HDA_AMP_MUTE, bits);
18263	snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18264				 HDA_AMP_MUTE, bits);
18265	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
18266				 HDA_AMP_MUTE, bits);
18267	snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
18268				 HDA_AMP_MUTE, bits);
18269}
18270
18271static void alc662_f5z_speaker_automute(struct hda_codec *codec)
18272{
18273	unsigned int present;
18274	unsigned char bits;
18275
18276	present = snd_hda_jack_detect(codec, 0x1b);
18277	bits = present ? 0 : PIN_OUT;
18278	snd_hda_codec_write(codec, 0x14, 0,
18279			 AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
18280}
18281
18282static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
18283{
18284	unsigned int present1, present2;
18285
18286	present1 = snd_hda_jack_detect(codec, 0x21);
18287	present2 = snd_hda_jack_detect(codec, 0x15);
18288
18289	if (present1 || present2) {
18290		snd_hda_codec_write_cache(codec, 0x14, 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	}
18296}
18297
18298static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
18299{
18300	unsigned int present1, present2;
18301
18302	present1 = snd_hda_jack_detect(codec, 0x1b);
18303	present2 = snd_hda_jack_detect(codec, 0x15);
18304
18305	if (present1 || present2) {
18306		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18307					 HDA_AMP_MUTE, HDA_AMP_MUTE);
18308		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18309					 HDA_AMP_MUTE, HDA_AMP_MUTE);
18310	} else {
18311		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
18312					 HDA_AMP_MUTE, 0);
18313		snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
18314					 HDA_AMP_MUTE, 0);
18315	}
18316}
18317
18318static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
18319{
18320	unsigned int present1, present2;
18321
18322	present1 = snd_hda_codec_read(codec, 0x1b, 0,
18323			AC_VERB_GET_PIN_SENSE, 0)
18324			& AC_PINSENSE_PRESENCE;
18325	present2 = snd_hda_codec_read(codec, 0x21, 0,
18326			AC_VERB_GET_PIN_SENSE, 0)
18327			& AC_PINSENSE_PRESENCE;
18328
18329	if (present1 || present2) {
18330		snd_hda_codec_write_cache(codec, 0x14, 0,
18331			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18332		snd_hda_codec_write_cache(codec, 0x17, 0,
18333			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18334	} else {
18335		snd_hda_codec_write_cache(codec, 0x14, 0,
18336			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18337		snd_hda_codec_write_cache(codec, 0x17, 0,
18338			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18339	}
18340}
18341
18342static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
18343{
18344	unsigned int present1, present2;
18345
18346	present1 = snd_hda_codec_read(codec, 0x21, 0,
18347			AC_VERB_GET_PIN_SENSE, 0)
18348			& AC_PINSENSE_PRESENCE;
18349	present2 = snd_hda_codec_read(codec, 0x15, 0,
18350			AC_VERB_GET_PIN_SENSE, 0)
18351			& AC_PINSENSE_PRESENCE;
18352
18353	if (present1 || present2) {
18354		snd_hda_codec_write_cache(codec, 0x14, 0,
18355			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18356		snd_hda_codec_write_cache(codec, 0x17, 0,
18357			AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
18358	} else {
18359		snd_hda_codec_write_cache(codec, 0x14, 0,
18360			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18361		snd_hda_codec_write_cache(codec, 0x17, 0,
18362			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
18363	}
18364}
18365
18366static void alc663_m51va_unsol_event(struct hda_codec *codec,
18367					   unsigned int res)
18368{
18369	switch (res >> 26) {
18370	case ALC880_HP_EVENT:
18371		alc663_m51va_speaker_automute(codec);
18372		break;
18373	case ALC880_MIC_EVENT:
18374		alc_mic_automute(codec);
18375		break;
18376	}
18377}
18378
18379static void alc663_m51va_setup(struct hda_codec *codec)
18380{
18381	struct alc_spec *spec = codec->spec;
18382	spec->ext_mic.pin = 0x18;
18383	spec->ext_mic.mux_idx = 0;
18384	spec->int_mic.pin = 0x12;
18385	spec->int_mic.mux_idx = 9;
18386	spec->auto_mic = 1;
18387}
18388
18389static void alc663_m51va_inithook(struct hda_codec *codec)
18390{
18391	alc663_m51va_speaker_automute(codec);
18392	alc_mic_automute(codec);
18393}
18394
18395/* ***************** Mode1 ******************************/
18396#define alc663_mode1_unsol_event	alc663_m51va_unsol_event
18397
18398static void alc663_mode1_setup(struct hda_codec *codec)
18399{
18400	struct alc_spec *spec = codec->spec;
18401	spec->ext_mic.pin = 0x18;
18402	spec->ext_mic.mux_idx = 0;
18403	spec->int_mic.pin = 0x19;
18404	spec->int_mic.mux_idx = 1;
18405	spec->auto_mic = 1;
18406}
18407
18408#define alc663_mode1_inithook		alc663_m51va_inithook
18409
18410/* ***************** Mode2 ******************************/
18411static void alc662_mode2_unsol_event(struct hda_codec *codec,
18412					   unsigned int res)
18413{
18414	switch (res >> 26) {
18415	case ALC880_HP_EVENT:
18416		alc662_f5z_speaker_automute(codec);
18417		break;
18418	case ALC880_MIC_EVENT:
18419		alc_mic_automute(codec);
18420		break;
18421	}
18422}
18423
18424#define alc662_mode2_setup	alc663_mode1_setup
18425
18426static void alc662_mode2_inithook(struct hda_codec *codec)
18427{
18428	alc662_f5z_speaker_automute(codec);
18429	alc_mic_automute(codec);
18430}
18431/* ***************** Mode3 ******************************/
18432static void alc663_mode3_unsol_event(struct hda_codec *codec,
18433					   unsigned int res)
18434{
18435	switch (res >> 26) {
18436	case ALC880_HP_EVENT:
18437		alc663_two_hp_m1_speaker_automute(codec);
18438		break;
18439	case ALC880_MIC_EVENT:
18440		alc_mic_automute(codec);
18441		break;
18442	}
18443}
18444
18445#define alc663_mode3_setup	alc663_mode1_setup
18446
18447static void alc663_mode3_inithook(struct hda_codec *codec)
18448{
18449	alc663_two_hp_m1_speaker_automute(codec);
18450	alc_mic_automute(codec);
18451}
18452/* ***************** Mode4 ******************************/
18453static void alc663_mode4_unsol_event(struct hda_codec *codec,
18454					   unsigned int res)
18455{
18456	switch (res >> 26) {
18457	case ALC880_HP_EVENT:
18458		alc663_21jd_two_speaker_automute(codec);
18459		break;
18460	case ALC880_MIC_EVENT:
18461		alc_mic_automute(codec);
18462		break;
18463	}
18464}
18465
18466#define alc663_mode4_setup	alc663_mode1_setup
18467
18468static void alc663_mode4_inithook(struct hda_codec *codec)
18469{
18470	alc663_21jd_two_speaker_automute(codec);
18471	alc_mic_automute(codec);
18472}
18473/* ***************** Mode5 ******************************/
18474static void alc663_mode5_unsol_event(struct hda_codec *codec,
18475					   unsigned int res)
18476{
18477	switch (res >> 26) {
18478	case ALC880_HP_EVENT:
18479		alc663_15jd_two_speaker_automute(codec);
18480		break;
18481	case ALC880_MIC_EVENT:
18482		alc_mic_automute(codec);
18483		break;
18484	}
18485}
18486
18487#define alc663_mode5_setup	alc663_mode1_setup
18488
18489static void alc663_mode5_inithook(struct hda_codec *codec)
18490{
18491	alc663_15jd_two_speaker_automute(codec);
18492	alc_mic_automute(codec);
18493}
18494/* ***************** Mode6 ******************************/
18495static void alc663_mode6_unsol_event(struct hda_codec *codec,
18496					   unsigned int res)
18497{
18498	switch (res >> 26) {
18499	case ALC880_HP_EVENT:
18500		alc663_two_hp_m2_speaker_automute(codec);
18501		break;
18502	case ALC880_MIC_EVENT:
18503		alc_mic_automute(codec);
18504		break;
18505	}
18506}
18507
18508#define alc663_mode6_setup	alc663_mode1_setup
18509
18510static void alc663_mode6_inithook(struct hda_codec *codec)
18511{
18512	alc663_two_hp_m2_speaker_automute(codec);
18513	alc_mic_automute(codec);
18514}
18515
18516/* ***************** Mode7 ******************************/
18517static void alc663_mode7_unsol_event(struct hda_codec *codec,
18518					   unsigned int res)
18519{
18520	switch (res >> 26) {
18521	case ALC880_HP_EVENT:
18522		alc663_two_hp_m7_speaker_automute(codec);
18523		break;
18524	case ALC880_MIC_EVENT:
18525		alc_mic_automute(codec);
18526		break;
18527	}
18528}
18529
18530#define alc663_mode7_setup	alc663_mode1_setup
18531
18532static void alc663_mode7_inithook(struct hda_codec *codec)
18533{
18534	alc663_two_hp_m7_speaker_automute(codec);
18535	alc_mic_automute(codec);
18536}
18537
18538/* ***************** Mode8 ******************************/
18539static void alc663_mode8_unsol_event(struct hda_codec *codec,
18540					   unsigned int res)
18541{
18542	switch (res >> 26) {
18543	case ALC880_HP_EVENT:
18544		alc663_two_hp_m8_speaker_automute(codec);
18545		break;
18546	case ALC880_MIC_EVENT:
18547		alc_mic_automute(codec);
18548		break;
18549	}
18550}
18551
18552#define alc663_mode8_setup	alc663_m51va_setup
18553
18554static void alc663_mode8_inithook(struct hda_codec *codec)
18555{
18556	alc663_two_hp_m8_speaker_automute(codec);
18557	alc_mic_automute(codec);
18558}
18559
18560static void alc663_g71v_hp_automute(struct hda_codec *codec)
18561{
18562	unsigned int present;
18563	unsigned char bits;
18564
18565	present = snd_hda_jack_detect(codec, 0x21);
18566	bits = present ? HDA_AMP_MUTE : 0;
18567	snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18568				 HDA_AMP_MUTE, bits);
18569	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18570				 HDA_AMP_MUTE, bits);
18571}
18572
18573static void alc663_g71v_front_automute(struct hda_codec *codec)
18574{
18575	unsigned int present;
18576	unsigned char bits;
18577
18578	present = snd_hda_jack_detect(codec, 0x15);
18579	bits = present ? HDA_AMP_MUTE : 0;
18580	snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18581				 HDA_AMP_MUTE, bits);
18582}
18583
18584static void alc663_g71v_unsol_event(struct hda_codec *codec,
18585					   unsigned int res)
18586{
18587	switch (res >> 26) {
18588	case ALC880_HP_EVENT:
18589		alc663_g71v_hp_automute(codec);
18590		break;
18591	case ALC880_FRONT_EVENT:
18592		alc663_g71v_front_automute(codec);
18593		break;
18594	case ALC880_MIC_EVENT:
18595		alc_mic_automute(codec);
18596		break;
18597	}
18598}
18599
18600#define alc663_g71v_setup	alc663_m51va_setup
18601
18602static void alc663_g71v_inithook(struct hda_codec *codec)
18603{
18604	alc663_g71v_front_automute(codec);
18605	alc663_g71v_hp_automute(codec);
18606	alc_mic_automute(codec);
18607}
18608
18609static void alc663_g50v_unsol_event(struct hda_codec *codec,
18610					   unsigned int res)
18611{
18612	switch (res >> 26) {
18613	case ALC880_HP_EVENT:
18614		alc663_m51va_speaker_automute(codec);
18615		break;
18616	case ALC880_MIC_EVENT:
18617		alc_mic_automute(codec);
18618		break;
18619	}
18620}
18621
18622#define alc663_g50v_setup	alc663_m51va_setup
18623
18624static void alc663_g50v_inithook(struct hda_codec *codec)
18625{
18626	alc663_m51va_speaker_automute(codec);
18627	alc_mic_automute(codec);
18628}
18629
18630static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18631	HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18632	ALC262_HIPPO_MASTER_SWITCH,
18633
18634	HDA_CODEC_VOLUME("Mic/LineIn Boost Volume", 0x18, 0, HDA_INPUT),
18635	HDA_CODEC_VOLUME("Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18636	HDA_CODEC_MUTE("Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18637
18638	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18639	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18640	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18641	{ } /* end */
18642};
18643
18644static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18645	/* Master Playback automatically created from Speaker and Headphone */
18646	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18647	HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18648	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18649	HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18650
18651	HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18652	HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18653	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
18654
18655	HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18656	HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18657	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x19, 0, HDA_INPUT),
18658	{ } /* end */
18659};
18660
18661#ifdef CONFIG_SND_HDA_POWER_SAVE
18662#define alc662_loopbacks	alc880_loopbacks
18663#endif
18664
18665
18666/* pcm configuration: identical with ALC880 */
18667#define alc662_pcm_analog_playback	alc880_pcm_analog_playback
18668#define alc662_pcm_analog_capture	alc880_pcm_analog_capture
18669#define alc662_pcm_digital_playback	alc880_pcm_digital_playback
18670#define alc662_pcm_digital_capture	alc880_pcm_digital_capture
18671
18672/*
18673 * configuration and preset
18674 */
18675static const char * const alc662_models[ALC662_MODEL_LAST] = {
18676	[ALC662_3ST_2ch_DIG]	= "3stack-dig",
18677	[ALC662_3ST_6ch_DIG]	= "3stack-6ch-dig",
18678	[ALC662_3ST_6ch]	= "3stack-6ch",
18679	[ALC662_5ST_DIG]	= "6stack-dig",
18680	[ALC662_LENOVO_101E]	= "lenovo-101e",
18681	[ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18682	[ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18683	[ALC662_ECS] = "ecs",
18684	[ALC663_ASUS_M51VA] = "m51va",
18685	[ALC663_ASUS_G71V] = "g71v",
18686	[ALC663_ASUS_H13] = "h13",
18687	[ALC663_ASUS_G50V] = "g50v",
18688	[ALC663_ASUS_MODE1] = "asus-mode1",
18689	[ALC662_ASUS_MODE2] = "asus-mode2",
18690	[ALC663_ASUS_MODE3] = "asus-mode3",
18691	[ALC663_ASUS_MODE4] = "asus-mode4",
18692	[ALC663_ASUS_MODE5] = "asus-mode5",
18693	[ALC663_ASUS_MODE6] = "asus-mode6",
18694	[ALC663_ASUS_MODE7] = "asus-mode7",
18695	[ALC663_ASUS_MODE8] = "asus-mode8",
18696	[ALC272_DELL]		= "dell",
18697	[ALC272_DELL_ZM1]	= "dell-zm1",
18698	[ALC272_SAMSUNG_NC10]	= "samsung-nc10",
18699	[ALC662_AUTO]		= "auto",
18700};
18701
18702static struct snd_pci_quirk alc662_cfg_tbl[] = {
18703	SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18704	SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18705	SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18706	SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18707	SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18708	SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18709	SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18710	SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18711	SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18712	SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18713	SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18714	SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18715	SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18716	SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18717	SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18718	SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18719	SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18720	SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18721	SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18722	SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18723	SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18724	SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18725	SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18726	SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18727	SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18728	SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18729	SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18730	SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18731	SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18732	SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18733	SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18734	SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18735	SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18736	SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18737	SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18738	SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18739	SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18740	/*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18741	SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18742	SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18743	SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18744	SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18745	SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18746	SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18747	SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18748	SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18749	SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18750	SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18751	SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18752	SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18753	SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18754	SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18755	SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18756	/*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18757	SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18758	SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18759	SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18760	SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18761	SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18762	SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18763	SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18764	SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18765	SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18766	SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18767		      ALC662_3ST_6ch_DIG),
18768	SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18769	SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18770	SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18771		      ALC662_3ST_6ch_DIG),
18772	SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18773	SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18774	SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18775	SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18776	SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18777					ALC662_3ST_6ch_DIG),
18778	SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18779			   ALC663_ASUS_H13),
18780	SND_PCI_QUIRK(0x1991, 0x5628, "Ordissimo EVE", ALC662_LENOVO_101E),
18781	{}
18782};
18783
18784static struct alc_config_preset alc662_presets[] = {
18785	[ALC662_3ST_2ch_DIG] = {
18786		.mixers = { alc662_3ST_2ch_mixer },
18787		.init_verbs = { alc662_init_verbs },
18788		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18789		.dac_nids = alc662_dac_nids,
18790		.dig_out_nid = ALC662_DIGOUT_NID,
18791		.dig_in_nid = ALC662_DIGIN_NID,
18792		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18793		.channel_mode = alc662_3ST_2ch_modes,
18794		.input_mux = &alc662_capture_source,
18795	},
18796	[ALC662_3ST_6ch_DIG] = {
18797		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18798		.init_verbs = { alc662_init_verbs },
18799		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18800		.dac_nids = alc662_dac_nids,
18801		.dig_out_nid = ALC662_DIGOUT_NID,
18802		.dig_in_nid = ALC662_DIGIN_NID,
18803		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18804		.channel_mode = alc662_3ST_6ch_modes,
18805		.need_dac_fix = 1,
18806		.input_mux = &alc662_capture_source,
18807	},
18808	[ALC662_3ST_6ch] = {
18809		.mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18810		.init_verbs = { alc662_init_verbs },
18811		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18812		.dac_nids = alc662_dac_nids,
18813		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18814		.channel_mode = alc662_3ST_6ch_modes,
18815		.need_dac_fix = 1,
18816		.input_mux = &alc662_capture_source,
18817	},
18818	[ALC662_5ST_DIG] = {
18819		.mixers = { alc662_base_mixer, alc662_chmode_mixer },
18820		.init_verbs = { alc662_init_verbs },
18821		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18822		.dac_nids = alc662_dac_nids,
18823		.dig_out_nid = ALC662_DIGOUT_NID,
18824		.dig_in_nid = ALC662_DIGIN_NID,
18825		.num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18826		.channel_mode = alc662_5stack_modes,
18827		.input_mux = &alc662_capture_source,
18828	},
18829	[ALC662_LENOVO_101E] = {
18830		.mixers = { alc662_lenovo_101e_mixer },
18831		.init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18832		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18833		.dac_nids = alc662_dac_nids,
18834		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18835		.channel_mode = alc662_3ST_2ch_modes,
18836		.input_mux = &alc662_lenovo_101e_capture_source,
18837		.unsol_event = alc662_lenovo_101e_unsol_event,
18838		.init_hook = alc662_lenovo_101e_all_automute,
18839	},
18840	[ALC662_ASUS_EEEPC_P701] = {
18841		.mixers = { alc662_eeepc_p701_mixer },
18842		.init_verbs = { alc662_init_verbs,
18843				alc662_eeepc_sue_init_verbs },
18844		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18845		.dac_nids = alc662_dac_nids,
18846		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18847		.channel_mode = alc662_3ST_2ch_modes,
18848		.unsol_event = alc662_eeepc_unsol_event,
18849		.setup = alc662_eeepc_setup,
18850		.init_hook = alc662_eeepc_inithook,
18851	},
18852	[ALC662_ASUS_EEEPC_EP20] = {
18853		.mixers = { alc662_eeepc_ep20_mixer,
18854			    alc662_chmode_mixer },
18855		.init_verbs = { alc662_init_verbs,
18856				alc662_eeepc_ep20_sue_init_verbs },
18857		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18858		.dac_nids = alc662_dac_nids,
18859		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18860		.channel_mode = alc662_3ST_6ch_modes,
18861		.input_mux = &alc662_lenovo_101e_capture_source,
18862		.unsol_event = alc662_eeepc_unsol_event,
18863		.setup = alc662_eeepc_ep20_setup,
18864		.init_hook = alc662_eeepc_ep20_inithook,
18865	},
18866	[ALC662_ECS] = {
18867		.mixers = { alc662_ecs_mixer },
18868		.init_verbs = { alc662_init_verbs,
18869				alc662_ecs_init_verbs },
18870		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18871		.dac_nids = alc662_dac_nids,
18872		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18873		.channel_mode = alc662_3ST_2ch_modes,
18874		.unsol_event = alc662_eeepc_unsol_event,
18875		.setup = alc662_eeepc_setup,
18876		.init_hook = alc662_eeepc_inithook,
18877	},
18878	[ALC663_ASUS_M51VA] = {
18879		.mixers = { alc663_m51va_mixer },
18880		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18881		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18882		.dac_nids = alc662_dac_nids,
18883		.dig_out_nid = ALC662_DIGOUT_NID,
18884		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18885		.channel_mode = alc662_3ST_2ch_modes,
18886		.unsol_event = alc663_m51va_unsol_event,
18887		.setup = alc663_m51va_setup,
18888		.init_hook = alc663_m51va_inithook,
18889	},
18890	[ALC663_ASUS_G71V] = {
18891		.mixers = { alc663_g71v_mixer },
18892		.init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18893		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
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_g71v_unsol_event,
18899		.setup = alc663_g71v_setup,
18900		.init_hook = alc663_g71v_inithook,
18901	},
18902	[ALC663_ASUS_H13] = {
18903		.mixers = { alc663_m51va_mixer },
18904		.init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18905		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18906		.dac_nids = alc662_dac_nids,
18907		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18908		.channel_mode = alc662_3ST_2ch_modes,
18909		.unsol_event = alc663_m51va_unsol_event,
18910		.init_hook = alc663_m51va_inithook,
18911	},
18912	[ALC663_ASUS_G50V] = {
18913		.mixers = { alc663_g50v_mixer },
18914		.init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18915		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18916		.dac_nids = alc662_dac_nids,
18917		.dig_out_nid = ALC662_DIGOUT_NID,
18918		.num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18919		.channel_mode = alc662_3ST_6ch_modes,
18920		.input_mux = &alc663_capture_source,
18921		.unsol_event = alc663_g50v_unsol_event,
18922		.setup = alc663_g50v_setup,
18923		.init_hook = alc663_g50v_inithook,
18924	},
18925	[ALC663_ASUS_MODE1] = {
18926		.mixers = { alc663_m51va_mixer },
18927		.cap_mixer = alc662_auto_capture_mixer,
18928		.init_verbs = { alc662_init_verbs,
18929				alc663_21jd_amic_init_verbs },
18930		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18931		.hp_nid = 0x03,
18932		.dac_nids = alc662_dac_nids,
18933		.dig_out_nid = ALC662_DIGOUT_NID,
18934		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18935		.channel_mode = alc662_3ST_2ch_modes,
18936		.unsol_event = alc663_mode1_unsol_event,
18937		.setup = alc663_mode1_setup,
18938		.init_hook = alc663_mode1_inithook,
18939	},
18940	[ALC662_ASUS_MODE2] = {
18941		.mixers = { alc662_1bjd_mixer },
18942		.cap_mixer = alc662_auto_capture_mixer,
18943		.init_verbs = { alc662_init_verbs,
18944				alc662_1bjd_amic_init_verbs },
18945		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18946		.dac_nids = alc662_dac_nids,
18947		.dig_out_nid = ALC662_DIGOUT_NID,
18948		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18949		.channel_mode = alc662_3ST_2ch_modes,
18950		.unsol_event = alc662_mode2_unsol_event,
18951		.setup = alc662_mode2_setup,
18952		.init_hook = alc662_mode2_inithook,
18953	},
18954	[ALC663_ASUS_MODE3] = {
18955		.mixers = { alc663_two_hp_m1_mixer },
18956		.cap_mixer = alc662_auto_capture_mixer,
18957		.init_verbs = { alc662_init_verbs,
18958				alc663_two_hp_amic_m1_init_verbs },
18959		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18960		.hp_nid = 0x03,
18961		.dac_nids = alc662_dac_nids,
18962		.dig_out_nid = ALC662_DIGOUT_NID,
18963		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18964		.channel_mode = alc662_3ST_2ch_modes,
18965		.unsol_event = alc663_mode3_unsol_event,
18966		.setup = alc663_mode3_setup,
18967		.init_hook = alc663_mode3_inithook,
18968	},
18969	[ALC663_ASUS_MODE4] = {
18970		.mixers = { alc663_asus_21jd_clfe_mixer },
18971		.cap_mixer = alc662_auto_capture_mixer,
18972		.init_verbs = { alc662_init_verbs,
18973				alc663_21jd_amic_init_verbs},
18974		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18975		.hp_nid = 0x03,
18976		.dac_nids = alc662_dac_nids,
18977		.dig_out_nid = ALC662_DIGOUT_NID,
18978		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18979		.channel_mode = alc662_3ST_2ch_modes,
18980		.unsol_event = alc663_mode4_unsol_event,
18981		.setup = alc663_mode4_setup,
18982		.init_hook = alc663_mode4_inithook,
18983	},
18984	[ALC663_ASUS_MODE5] = {
18985		.mixers = { alc663_asus_15jd_clfe_mixer },
18986		.cap_mixer = alc662_auto_capture_mixer,
18987		.init_verbs = { alc662_init_verbs,
18988				alc663_15jd_amic_init_verbs },
18989		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
18990		.hp_nid = 0x03,
18991		.dac_nids = alc662_dac_nids,
18992		.dig_out_nid = ALC662_DIGOUT_NID,
18993		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18994		.channel_mode = alc662_3ST_2ch_modes,
18995		.unsol_event = alc663_mode5_unsol_event,
18996		.setup = alc663_mode5_setup,
18997		.init_hook = alc663_mode5_inithook,
18998	},
18999	[ALC663_ASUS_MODE6] = {
19000		.mixers = { alc663_two_hp_m2_mixer },
19001		.cap_mixer = alc662_auto_capture_mixer,
19002		.init_verbs = { alc662_init_verbs,
19003				alc663_two_hp_amic_m2_init_verbs },
19004		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
19005		.hp_nid = 0x03,
19006		.dac_nids = alc662_dac_nids,
19007		.dig_out_nid = ALC662_DIGOUT_NID,
19008		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19009		.channel_mode = alc662_3ST_2ch_modes,
19010		.unsol_event = alc663_mode6_unsol_event,
19011		.setup = alc663_mode6_setup,
19012		.init_hook = alc663_mode6_inithook,
19013	},
19014	[ALC663_ASUS_MODE7] = {
19015		.mixers = { alc663_mode7_mixer },
19016		.cap_mixer = alc662_auto_capture_mixer,
19017		.init_verbs = { alc662_init_verbs,
19018				alc663_mode7_init_verbs },
19019		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
19020		.hp_nid = 0x03,
19021		.dac_nids = alc662_dac_nids,
19022		.dig_out_nid = ALC662_DIGOUT_NID,
19023		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19024		.channel_mode = alc662_3ST_2ch_modes,
19025		.unsol_event = alc663_mode7_unsol_event,
19026		.setup = alc663_mode7_setup,
19027		.init_hook = alc663_mode7_inithook,
19028	},
19029	[ALC663_ASUS_MODE8] = {
19030		.mixers = { alc663_mode8_mixer },
19031		.cap_mixer = alc662_auto_capture_mixer,
19032		.init_verbs = { alc662_init_verbs,
19033				alc663_mode8_init_verbs },
19034		.num_dacs = ARRAY_SIZE(alc662_dac_nids),
19035		.hp_nid = 0x03,
19036		.dac_nids = alc662_dac_nids,
19037		.dig_out_nid = ALC662_DIGOUT_NID,
19038		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19039		.channel_mode = alc662_3ST_2ch_modes,
19040		.unsol_event = alc663_mode8_unsol_event,
19041		.setup = alc663_mode8_setup,
19042		.init_hook = alc663_mode8_inithook,
19043	},
19044	[ALC272_DELL] = {
19045		.mixers = { alc663_m51va_mixer },
19046		.cap_mixer = alc272_auto_capture_mixer,
19047		.init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
19048		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
19049		.dac_nids = alc662_dac_nids,
19050		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19051		.adc_nids = alc272_adc_nids,
19052		.num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
19053		.capsrc_nids = alc272_capsrc_nids,
19054		.channel_mode = alc662_3ST_2ch_modes,
19055		.unsol_event = alc663_m51va_unsol_event,
19056		.setup = alc663_m51va_setup,
19057		.init_hook = alc663_m51va_inithook,
19058	},
19059	[ALC272_DELL_ZM1] = {
19060		.mixers = { alc663_m51va_mixer },
19061		.cap_mixer = alc662_auto_capture_mixer,
19062		.init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
19063		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
19064		.dac_nids = alc662_dac_nids,
19065		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19066		.adc_nids = alc662_adc_nids,
19067		.num_adc_nids = 1,
19068		.capsrc_nids = alc662_capsrc_nids,
19069		.channel_mode = alc662_3ST_2ch_modes,
19070		.unsol_event = alc663_m51va_unsol_event,
19071		.setup = alc663_m51va_setup,
19072		.init_hook = alc663_m51va_inithook,
19073	},
19074	[ALC272_SAMSUNG_NC10] = {
19075		.mixers = { alc272_nc10_mixer },
19076		.init_verbs = { alc662_init_verbs,
19077				alc663_21jd_amic_init_verbs },
19078		.num_dacs = ARRAY_SIZE(alc272_dac_nids),
19079		.dac_nids = alc272_dac_nids,
19080		.num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
19081		.channel_mode = alc662_3ST_2ch_modes,
19082		/*.input_mux = &alc272_nc10_capture_source,*/
19083		.unsol_event = alc663_mode4_unsol_event,
19084		.setup = alc663_mode4_setup,
19085		.init_hook = alc663_mode4_inithook,
19086	},
19087};
19088
19089
19090/*
19091 * BIOS auto configuration
19092 */
19093
19094/* convert from MIX nid to DAC */
19095static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
19096{
19097	if (nid == 0x0f)
19098		return 0x02;
19099	else if (nid >= 0x0c && nid <= 0x0e)
19100		return nid - 0x0c + 0x02;
19101	else if (nid == 0x26) /* ALC887-VD has this DAC too */
19102		return 0x25;
19103	else
19104		return 0;
19105}
19106
19107/* get MIX nid connected to the given pin targeted to DAC */
19108static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
19109				   hda_nid_t dac)
19110{
19111	hda_nid_t mix[5];
19112	int i, num;
19113
19114	num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
19115	for (i = 0; i < num; i++) {
19116		if (alc662_mix_to_dac(mix[i]) == dac)
19117			return mix[i];
19118	}
19119	return 0;
19120}
19121
19122/* look for an empty DAC slot */
19123static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
19124{
19125	struct alc_spec *spec = codec->spec;
19126	hda_nid_t srcs[5];
19127	int i, j, num;
19128
19129	num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
19130	if (num < 0)
19131		return 0;
19132	for (i = 0; i < num; i++) {
19133		hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
19134		if (!nid)
19135			continue;
19136		for (j = 0; j < spec->multiout.num_dacs; j++)
19137			if (spec->multiout.dac_nids[j] == nid)
19138				break;
19139		if (j >= spec->multiout.num_dacs)
19140			return nid;
19141	}
19142	return 0;
19143}
19144
19145/* fill in the dac_nids table from the parsed pin configuration */
19146static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
19147				     const struct auto_pin_cfg *cfg)
19148{
19149	struct alc_spec *spec = codec->spec;
19150	int i;
19151	hda_nid_t dac;
19152
19153	spec->multiout.dac_nids = spec->private_dac_nids;
19154	for (i = 0; i < cfg->line_outs; i++) {
19155		dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
19156		if (!dac)
19157			continue;
19158		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19159	}
19160	return 0;
19161}
19162
19163static inline int __alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
19164				       hda_nid_t nid, int idx, unsigned int chs)
19165{
19166	return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx,
19167			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
19168}
19169
19170static inline int __alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
19171				      hda_nid_t nid, int idx, unsigned int chs)
19172{
19173	return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx,
19174			   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
19175}
19176
19177#define alc662_add_vol_ctl(spec, pfx, nid, chs) \
19178	__alc662_add_vol_ctl(spec, pfx, nid, 0, chs)
19179#define alc662_add_sw_ctl(spec, pfx, nid, chs) \
19180	__alc662_add_sw_ctl(spec, pfx, nid, 0, chs)
19181#define alc662_add_stereo_vol(spec, pfx, nid) \
19182	alc662_add_vol_ctl(spec, pfx, nid, 3)
19183#define alc662_add_stereo_sw(spec, pfx, nid) \
19184	alc662_add_sw_ctl(spec, pfx, nid, 3)
19185
19186/* add playback controls from the parsed DAC table */
19187static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
19188					     const struct auto_pin_cfg *cfg)
19189{
19190	struct alc_spec *spec = codec->spec;
19191	static const char * const chname[4] = {
19192		"Front", "Surround", NULL /*CLFE*/, "Side"
19193	};
19194	const char *pfx = alc_get_line_out_pfx(cfg, true);
19195	hda_nid_t nid, mix;
19196	int i, err;
19197
19198	for (i = 0; i < cfg->line_outs; i++) {
19199		nid = spec->multiout.dac_nids[i];
19200		if (!nid)
19201			continue;
19202		mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
19203		if (!mix)
19204			continue;
19205		if (!pfx && i == 2) {
19206			/* Center/LFE */
19207			err = alc662_add_vol_ctl(spec, "Center", nid, 1);
19208			if (err < 0)
19209				return err;
19210			err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
19211			if (err < 0)
19212				return err;
19213			err = alc662_add_sw_ctl(spec, "Center", mix, 1);
19214			if (err < 0)
19215				return err;
19216			err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
19217			if (err < 0)
19218				return err;
19219		} else {
19220			const char *name = pfx;
19221			if (!name)
19222				name = chname[i];
19223			err = __alc662_add_vol_ctl(spec, name, nid, i, 3);
19224			if (err < 0)
19225				return err;
19226			err = __alc662_add_sw_ctl(spec, name, mix, i, 3);
19227			if (err < 0)
19228				return err;
19229		}
19230	}
19231	return 0;
19232}
19233
19234/* add playback controls for speaker and HP outputs */
19235/* return DAC nid if any new DAC is assigned */
19236static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
19237					const char *pfx)
19238{
19239	struct alc_spec *spec = codec->spec;
19240	hda_nid_t nid, mix;
19241	int err;
19242
19243	if (!pin)
19244		return 0;
19245	nid = alc662_look_for_dac(codec, pin);
19246	if (!nid) {
19247		/* the corresponding DAC is already occupied */
19248		if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
19249			return 0; /* no way */
19250		/* create a switch only */
19251		return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
19252				   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
19253	}
19254
19255	mix = alc662_dac_to_mix(codec, pin, nid);
19256	if (!mix)
19257		return 0;
19258	err = alc662_add_vol_ctl(spec, pfx, nid, 3);
19259	if (err < 0)
19260		return err;
19261	err = alc662_add_sw_ctl(spec, pfx, mix, 3);
19262	if (err < 0)
19263		return err;
19264	return nid;
19265}
19266
19267/* create playback/capture controls for input pins */
19268#define alc662_auto_create_input_ctls \
19269	alc882_auto_create_input_ctls
19270
19271static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
19272					      hda_nid_t nid, int pin_type,
19273					      hda_nid_t dac)
19274{
19275	int i, num;
19276	hda_nid_t srcs[HDA_MAX_CONNECTIONS];
19277
19278	alc_set_pin_output(codec, nid, pin_type);
19279	/* need the manual connection? */
19280	num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
19281	if (num <= 1)
19282		return;
19283	for (i = 0; i < num; i++) {
19284		if (alc662_mix_to_dac(srcs[i]) != dac)
19285			continue;
19286		snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
19287		return;
19288	}
19289}
19290
19291static void alc662_auto_init_multi_out(struct hda_codec *codec)
19292{
19293	struct alc_spec *spec = codec->spec;
19294	int pin_type = get_pin_type(spec->autocfg.line_out_type);
19295	int i;
19296
19297	for (i = 0; i <= HDA_SIDE; i++) {
19298		hda_nid_t nid = spec->autocfg.line_out_pins[i];
19299		if (nid)
19300			alc662_auto_set_output_and_unmute(codec, nid, pin_type,
19301					spec->multiout.dac_nids[i]);
19302	}
19303}
19304
19305static void alc662_auto_init_hp_out(struct hda_codec *codec)
19306{
19307	struct alc_spec *spec = codec->spec;
19308	hda_nid_t pin;
19309
19310	pin = spec->autocfg.hp_pins[0];
19311	if (pin)
19312		alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
19313						  spec->multiout.hp_nid);
19314	pin = spec->autocfg.speaker_pins[0];
19315	if (pin)
19316		alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
19317					spec->multiout.extra_out_nid[0]);
19318}
19319
19320#define ALC662_PIN_CD_NID		ALC880_PIN_CD_NID
19321
19322static void alc662_auto_init_analog_input(struct hda_codec *codec)
19323{
19324	struct alc_spec *spec = codec->spec;
19325	struct auto_pin_cfg *cfg = &spec->autocfg;
19326	int i;
19327
19328	for (i = 0; i < cfg->num_inputs; i++) {
19329		hda_nid_t nid = cfg->inputs[i].pin;
19330		if (alc_is_input_pin(codec, nid)) {
19331			alc_set_input_pin(codec, nid, cfg->inputs[i].type);
19332			if (nid != ALC662_PIN_CD_NID &&
19333			    (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
19334				snd_hda_codec_write(codec, nid, 0,
19335						    AC_VERB_SET_AMP_GAIN_MUTE,
19336						    AMP_OUT_MUTE);
19337		}
19338	}
19339}
19340
19341#define alc662_auto_init_input_src	alc882_auto_init_input_src
19342
19343static int alc662_parse_auto_config(struct hda_codec *codec)
19344{
19345	struct alc_spec *spec = codec->spec;
19346	int err;
19347	static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
19348
19349	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19350					   alc662_ignore);
19351	if (err < 0)
19352		return err;
19353	if (!spec->autocfg.line_outs)
19354		return 0; /* can't find valid BIOS pin config */
19355
19356	err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
19357	if (err < 0)
19358		return err;
19359	err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
19360	if (err < 0)
19361		return err;
19362	err = alc662_auto_create_extra_out(codec,
19363					   spec->autocfg.speaker_pins[0],
19364					   "Speaker");
19365	if (err < 0)
19366		return err;
19367	if (err)
19368		spec->multiout.extra_out_nid[0] = err;
19369	err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
19370					   "Headphone");
19371	if (err < 0)
19372		return err;
19373	if (err)
19374		spec->multiout.hp_nid = err;
19375	err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
19376	if (err < 0)
19377		return err;
19378
19379	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
19380
19381	alc_auto_parse_digital(codec);
19382
19383	if (spec->kctls.list)
19384		add_mixer(spec, spec->kctls.list);
19385
19386	spec->num_mux_defs = 1;
19387	spec->input_mux = &spec->private_imux[0];
19388
19389	add_verb(spec, alc662_init_verbs);
19390	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19391	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19392		add_verb(spec, alc663_init_verbs);
19393
19394	if (codec->vendor_id == 0x10ec0272)
19395		add_verb(spec, alc272_init_verbs);
19396
19397	err = alc_auto_add_mic_boost(codec);
19398	if (err < 0)
19399		return err;
19400
19401	if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
19402	    codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
19403	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
19404	else
19405	    alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
19406
19407	return 1;
19408}
19409
19410/* additional initialization for auto-configuration model */
19411static void alc662_auto_init(struct hda_codec *codec)
19412{
19413	struct alc_spec *spec = codec->spec;
19414	alc662_auto_init_multi_out(codec);
19415	alc662_auto_init_hp_out(codec);
19416	alc662_auto_init_analog_input(codec);
19417	alc662_auto_init_input_src(codec);
19418	alc_auto_init_digital(codec);
19419	if (spec->unsol_event)
19420		alc_inithook(codec);
19421}
19422
19423static void alc272_fixup_mario(struct hda_codec *codec,
19424			       const struct alc_fixup *fix, int action)
19425{
19426	if (action != ALC_FIXUP_ACT_PROBE)
19427		return;
19428	if (snd_hda_override_amp_caps(codec, 0x2, HDA_OUTPUT,
19429				      (0x3b << AC_AMPCAP_OFFSET_SHIFT) |
19430				      (0x3b << AC_AMPCAP_NUM_STEPS_SHIFT) |
19431				      (0x03 << AC_AMPCAP_STEP_SIZE_SHIFT) |
19432				      (0 << AC_AMPCAP_MUTE_SHIFT)))
19433		printk(KERN_WARNING
19434		       "hda_codec: failed to override amp caps for NID 0x2\n");
19435}
19436
19437enum {
19438	ALC662_FIXUP_ASPIRE,
19439	ALC662_FIXUP_IDEAPAD,
19440	ALC272_FIXUP_MARIO,
19441	ALC662_FIXUP_CZC_P10T,
19442};
19443
19444static const struct alc_fixup alc662_fixups[] = {
19445	[ALC662_FIXUP_ASPIRE] = {
19446		.type = ALC_FIXUP_PINS,
19447		.v.pins = (const struct alc_pincfg[]) {
19448			{ 0x15, 0x99130112 }, /* subwoofer */
19449			{ }
19450		}
19451	},
19452	[ALC662_FIXUP_IDEAPAD] = {
19453		.type = ALC_FIXUP_PINS,
19454		.v.pins = (const struct alc_pincfg[]) {
19455			{ 0x17, 0x99130112 }, /* subwoofer */
19456			{ }
19457		}
19458	},
19459	[ALC272_FIXUP_MARIO] = {
19460		.type = ALC_FIXUP_FUNC,
19461		.v.func = alc272_fixup_mario,
19462	},
19463	[ALC662_FIXUP_CZC_P10T] = {
19464		.type = ALC_FIXUP_VERBS,
19465		.v.verbs = (const struct hda_verb[]) {
19466			{0x14, AC_VERB_SET_EAPD_BTLENABLE, 0},
19467			{}
19468		}
19469	},
19470};
19471
19472static struct snd_pci_quirk alc662_fixup_tbl[] = {
19473	SND_PCI_QUIRK(0x1025, 0x0308, "Acer Aspire 8942G", ALC662_FIXUP_ASPIRE),
19474	SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE),
19475	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
19476	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
19477	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
19478	SND_PCI_QUIRK(0x1b35, 0x2206, "CZC P10T", ALC662_FIXUP_CZC_P10T),
19479	{}
19480};
19481
19482static const struct alc_model_fixup alc662_fixup_models[] = {
19483	{.id = ALC272_FIXUP_MARIO, .name = "mario"},
19484	{}
19485};
19486
19487
19488static int patch_alc662(struct hda_codec *codec)
19489{
19490	struct alc_spec *spec;
19491	int err, board_config;
19492	int coef;
19493
19494	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19495	if (!spec)
19496		return -ENOMEM;
19497
19498	codec->spec = spec;
19499
19500	alc_auto_parse_customize_define(codec);
19501
19502	alc_fix_pll_init(codec, 0x20, 0x04, 15);
19503
19504	coef = alc_read_coef_idx(codec, 0);
19505	if (coef == 0x8020 || coef == 0x8011)
19506		alc_codec_rename(codec, "ALC661");
19507	else if (coef & (1 << 14) &&
19508		codec->bus->pci->subsystem_vendor == 0x1025 &&
19509		spec->cdefine.platform_type == 1)
19510		alc_codec_rename(codec, "ALC272X");
19511	else if (coef == 0x4011)
19512		alc_codec_rename(codec, "ALC656");
19513
19514	board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
19515						  alc662_models,
19516			  	                  alc662_cfg_tbl);
19517	if (board_config < 0) {
19518		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19519		       codec->chip_name);
19520		board_config = ALC662_AUTO;
19521	}
19522
19523	if (board_config == ALC662_AUTO) {
19524		alc_pick_fixup(codec, alc662_fixup_models,
19525			       alc662_fixup_tbl, alc662_fixups);
19526		alc_apply_fixup(codec, ALC_FIXUP_ACT_PRE_PROBE);
19527		/* automatic parse from the BIOS config */
19528		err = alc662_parse_auto_config(codec);
19529		if (err < 0) {
19530			alc_free(codec);
19531			return err;
19532		} else if (!err) {
19533			printk(KERN_INFO
19534			       "hda_codec: Cannot set up configuration "
19535			       "from BIOS.  Using base mode...\n");
19536			board_config = ALC662_3ST_2ch_DIG;
19537		}
19538	}
19539
19540	if (has_cdefine_beep(codec)) {
19541		err = snd_hda_attach_beep_device(codec, 0x1);
19542		if (err < 0) {
19543			alc_free(codec);
19544			return err;
19545		}
19546	}
19547
19548	if (board_config != ALC662_AUTO)
19549		setup_preset(codec, &alc662_presets[board_config]);
19550
19551	spec->stream_analog_playback = &alc662_pcm_analog_playback;
19552	spec->stream_analog_capture = &alc662_pcm_analog_capture;
19553
19554	spec->stream_digital_playback = &alc662_pcm_digital_playback;
19555	spec->stream_digital_capture = &alc662_pcm_digital_capture;
19556
19557	if (!spec->adc_nids) {
19558		spec->adc_nids = alc662_adc_nids;
19559		spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
19560	}
19561	if (!spec->capsrc_nids)
19562		spec->capsrc_nids = alc662_capsrc_nids;
19563
19564	if (!spec->cap_mixer)
19565		set_capture_mixer(codec);
19566
19567	if (has_cdefine_beep(codec)) {
19568		switch (codec->vendor_id) {
19569		case 0x10ec0662:
19570			set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19571			break;
19572		case 0x10ec0272:
19573		case 0x10ec0663:
19574		case 0x10ec0665:
19575			set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19576			break;
19577		case 0x10ec0273:
19578			set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19579			break;
19580		}
19581	}
19582	spec->vmaster_nid = 0x02;
19583
19584	alc_apply_fixup(codec, ALC_FIXUP_ACT_PROBE);
19585
19586	codec->patch_ops = alc_patch_ops;
19587	if (board_config == ALC662_AUTO)
19588		spec->init_hook = alc662_auto_init;
19589
19590	alc_init_jacks(codec);
19591
19592#ifdef CONFIG_SND_HDA_POWER_SAVE
19593	if (!spec->loopback.amplist)
19594		spec->loopback.amplist = alc662_loopbacks;
19595#endif
19596
19597	return 0;
19598}
19599
19600static int patch_alc888(struct hda_codec *codec)
19601{
19602	if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19603		kfree(codec->chip_name);
19604		if (codec->vendor_id == 0x10ec0887)
19605			codec->chip_name = kstrdup("ALC887-VD", GFP_KERNEL);
19606		else
19607			codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19608		if (!codec->chip_name) {
19609			alc_free(codec);
19610			return -ENOMEM;
19611		}
19612		return patch_alc662(codec);
19613	}
19614	return patch_alc882(codec);
19615}
19616
19617/*
19618 * ALC680 support
19619 */
19620#define ALC680_DIGIN_NID	ALC880_DIGIN_NID
19621#define ALC680_DIGOUT_NID	ALC880_DIGOUT_NID
19622#define alc680_modes		alc260_modes
19623
19624static hda_nid_t alc680_dac_nids[3] = {
19625	/* Lout1, Lout2, hp */
19626	0x02, 0x03, 0x04
19627};
19628
19629static hda_nid_t alc680_adc_nids[3] = {
19630	/* ADC0-2 */
19631	/* DMIC, MIC, Line-in*/
19632	0x07, 0x08, 0x09
19633};
19634
19635/*
19636 * Analog capture ADC cgange
19637 */
19638static void alc680_rec_autoswitch(struct hda_codec *codec)
19639{
19640	struct alc_spec *spec = codec->spec;
19641	struct auto_pin_cfg *cfg = &spec->autocfg;
19642	int pin_found = 0;
19643	int type_found = AUTO_PIN_LAST;
19644	hda_nid_t nid;
19645	int i;
19646
19647	for (i = 0; i < cfg->num_inputs; i++) {
19648		nid = cfg->inputs[i].pin;
19649		if (!(snd_hda_query_pin_caps(codec, nid) &
19650		      AC_PINCAP_PRES_DETECT))
19651			continue;
19652		if (snd_hda_jack_detect(codec, nid)) {
19653			if (cfg->inputs[i].type < type_found) {
19654				type_found = cfg->inputs[i].type;
19655				pin_found = nid;
19656			}
19657		}
19658	}
19659
19660	nid = 0x07;
19661	if (pin_found)
19662		snd_hda_get_connections(codec, pin_found, &nid, 1);
19663
19664	if (nid != spec->cur_adc)
19665		__snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19666	spec->cur_adc = nid;
19667	snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19668				   spec->cur_adc_format);
19669}
19670
19671static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19672				      struct hda_codec *codec,
19673				      unsigned int stream_tag,
19674				      unsigned int format,
19675				      struct snd_pcm_substream *substream)
19676{
19677	struct alc_spec *spec = codec->spec;
19678
19679	spec->cur_adc = 0x07;
19680	spec->cur_adc_stream_tag = stream_tag;
19681	spec->cur_adc_format = format;
19682
19683	alc680_rec_autoswitch(codec);
19684	return 0;
19685}
19686
19687static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19688				      struct hda_codec *codec,
19689				      struct snd_pcm_substream *substream)
19690{
19691	snd_hda_codec_cleanup_stream(codec, 0x07);
19692	snd_hda_codec_cleanup_stream(codec, 0x08);
19693	snd_hda_codec_cleanup_stream(codec, 0x09);
19694	return 0;
19695}
19696
19697static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19698	.substreams = 1, /* can be overridden */
19699	.channels_min = 2,
19700	.channels_max = 2,
19701	/* NID is set in alc_build_pcms */
19702	.ops = {
19703		.prepare = alc680_capture_pcm_prepare,
19704		.cleanup = alc680_capture_pcm_cleanup
19705	},
19706};
19707
19708static struct snd_kcontrol_new alc680_base_mixer[] = {
19709	/* output mixer control */
19710	HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19711	HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19712	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19713	HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19714	HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x12, 0, HDA_INPUT),
19715	HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0, HDA_INPUT),
19716	HDA_CODEC_VOLUME("Line In Boost Volume", 0x19, 0, HDA_INPUT),
19717	{ }
19718};
19719
19720static struct hda_bind_ctls alc680_bind_cap_vol = {
19721	.ops = &snd_hda_bind_vol,
19722	.values = {
19723		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19724		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19725		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19726		0
19727	},
19728};
19729
19730static struct hda_bind_ctls alc680_bind_cap_switch = {
19731	.ops = &snd_hda_bind_sw,
19732	.values = {
19733		HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19734		HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19735		HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19736		0
19737	},
19738};
19739
19740static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19741	HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19742	HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19743	{ } /* end */
19744};
19745
19746/*
19747 * generic initialization of ADC, input mixers and output mixers
19748 */
19749static struct hda_verb alc680_init_verbs[] = {
19750	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19751	{0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19752	{0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19753
19754	{0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19755	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19756	{0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19757	{0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19758	{0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19759	{0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19760
19761	{0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19762	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19763	{0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19764	{0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19765	{0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19766
19767	{0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19768	{0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19769	{0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19770
19771	{ }
19772};
19773
19774/* toggle speaker-output according to the hp-jack state */
19775static void alc680_base_setup(struct hda_codec *codec)
19776{
19777	struct alc_spec *spec = codec->spec;
19778
19779	spec->autocfg.hp_pins[0] = 0x16;
19780	spec->autocfg.speaker_pins[0] = 0x14;
19781	spec->autocfg.speaker_pins[1] = 0x15;
19782	spec->autocfg.num_inputs = 2;
19783	spec->autocfg.inputs[0].pin = 0x18;
19784	spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19785	spec->autocfg.inputs[1].pin = 0x19;
19786	spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN;
19787}
19788
19789static void alc680_unsol_event(struct hda_codec *codec,
19790					   unsigned int res)
19791{
19792	if ((res >> 26) == ALC880_HP_EVENT)
19793		alc_automute_amp(codec);
19794	if ((res >> 26) == ALC880_MIC_EVENT)
19795		alc680_rec_autoswitch(codec);
19796}
19797
19798static void alc680_inithook(struct hda_codec *codec)
19799{
19800	alc_automute_amp(codec);
19801	alc680_rec_autoswitch(codec);
19802}
19803
19804/* create input playback/capture controls for the given pin */
19805static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19806				    const char *ctlname, int idx)
19807{
19808	hda_nid_t dac;
19809	int err;
19810
19811	switch (nid) {
19812	case 0x14:
19813		dac = 0x02;
19814		break;
19815	case 0x15:
19816		dac = 0x03;
19817		break;
19818	case 0x16:
19819		dac = 0x04;
19820		break;
19821	default:
19822		return 0;
19823	}
19824	if (spec->multiout.dac_nids[0] != dac &&
19825	    spec->multiout.dac_nids[1] != dac) {
19826		err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19827				  HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19828						      HDA_OUTPUT));
19829		if (err < 0)
19830			return err;
19831
19832		err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19833			  HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19834
19835		if (err < 0)
19836			return err;
19837		spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19838	}
19839
19840	return 0;
19841}
19842
19843/* add playback controls from the parsed DAC table */
19844static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19845					     const struct auto_pin_cfg *cfg)
19846{
19847	hda_nid_t nid;
19848	int err;
19849
19850	spec->multiout.dac_nids = spec->private_dac_nids;
19851
19852	nid = cfg->line_out_pins[0];
19853	if (nid) {
19854		const char *name;
19855		if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19856			name = "Speaker";
19857		else
19858			name = "Front";
19859		err = alc680_new_analog_output(spec, nid, name, 0);
19860		if (err < 0)
19861			return err;
19862	}
19863
19864	nid = cfg->speaker_pins[0];
19865	if (nid) {
19866		err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19867		if (err < 0)
19868			return err;
19869	}
19870	nid = cfg->hp_pins[0];
19871	if (nid) {
19872		err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19873		if (err < 0)
19874			return err;
19875	}
19876
19877	return 0;
19878}
19879
19880static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19881					      hda_nid_t nid, int pin_type)
19882{
19883	alc_set_pin_output(codec, nid, pin_type);
19884}
19885
19886static void alc680_auto_init_multi_out(struct hda_codec *codec)
19887{
19888	struct alc_spec *spec = codec->spec;
19889	hda_nid_t nid = spec->autocfg.line_out_pins[0];
19890	if (nid) {
19891		int pin_type = get_pin_type(spec->autocfg.line_out_type);
19892		alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19893	}
19894}
19895
19896static void alc680_auto_init_hp_out(struct hda_codec *codec)
19897{
19898	struct alc_spec *spec = codec->spec;
19899	hda_nid_t pin;
19900
19901	pin = spec->autocfg.hp_pins[0];
19902	if (pin)
19903		alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19904	pin = spec->autocfg.speaker_pins[0];
19905	if (pin)
19906		alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19907}
19908
19909/* pcm configuration: identical with ALC880 */
19910#define alc680_pcm_analog_playback	alc880_pcm_analog_playback
19911#define alc680_pcm_analog_capture	alc880_pcm_analog_capture
19912#define alc680_pcm_analog_alt_capture	alc880_pcm_analog_alt_capture
19913#define alc680_pcm_digital_playback	alc880_pcm_digital_playback
19914#define alc680_pcm_digital_capture	alc880_pcm_digital_capture
19915
19916/*
19917 * BIOS auto configuration
19918 */
19919static int alc680_parse_auto_config(struct hda_codec *codec)
19920{
19921	struct alc_spec *spec = codec->spec;
19922	int err;
19923	static hda_nid_t alc680_ignore[] = { 0 };
19924
19925	err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19926					   alc680_ignore);
19927	if (err < 0)
19928		return err;
19929
19930	if (!spec->autocfg.line_outs) {
19931		if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19932			spec->multiout.max_channels = 2;
19933			spec->no_analog = 1;
19934			goto dig_only;
19935		}
19936		return 0; /* can't find valid BIOS pin config */
19937	}
19938	err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19939	if (err < 0)
19940		return err;
19941
19942	spec->multiout.max_channels = 2;
19943
19944 dig_only:
19945	/* digital only support output */
19946	alc_auto_parse_digital(codec);
19947	if (spec->kctls.list)
19948		add_mixer(spec, spec->kctls.list);
19949
19950	add_verb(spec, alc680_init_verbs);
19951
19952	err = alc_auto_add_mic_boost(codec);
19953	if (err < 0)
19954		return err;
19955
19956	return 1;
19957}
19958
19959#define alc680_auto_init_analog_input	alc882_auto_init_analog_input
19960
19961/* init callback for auto-configuration model -- overriding the default init */
19962static void alc680_auto_init(struct hda_codec *codec)
19963{
19964	struct alc_spec *spec = codec->spec;
19965	alc680_auto_init_multi_out(codec);
19966	alc680_auto_init_hp_out(codec);
19967	alc680_auto_init_analog_input(codec);
19968	alc_auto_init_digital(codec);
19969	if (spec->unsol_event)
19970		alc_inithook(codec);
19971}
19972
19973/*
19974 * configuration and preset
19975 */
19976static const char * const alc680_models[ALC680_MODEL_LAST] = {
19977	[ALC680_BASE]		= "base",
19978	[ALC680_AUTO]		= "auto",
19979};
19980
19981static struct snd_pci_quirk alc680_cfg_tbl[] = {
19982	SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19983	{}
19984};
19985
19986static struct alc_config_preset alc680_presets[] = {
19987	[ALC680_BASE] = {
19988		.mixers = { alc680_base_mixer },
19989		.cap_mixer =  alc680_master_capture_mixer,
19990		.init_verbs = { alc680_init_verbs },
19991		.num_dacs = ARRAY_SIZE(alc680_dac_nids),
19992		.dac_nids = alc680_dac_nids,
19993		.dig_out_nid = ALC680_DIGOUT_NID,
19994		.num_channel_mode = ARRAY_SIZE(alc680_modes),
19995		.channel_mode = alc680_modes,
19996		.unsol_event = alc680_unsol_event,
19997		.setup = alc680_base_setup,
19998		.init_hook = alc680_inithook,
19999
20000	},
20001};
20002
20003static int patch_alc680(struct hda_codec *codec)
20004{
20005	struct alc_spec *spec;
20006	int board_config;
20007	int err;
20008
20009	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
20010	if (spec == NULL)
20011		return -ENOMEM;
20012
20013	codec->spec = spec;
20014
20015	board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
20016						  alc680_models,
20017						  alc680_cfg_tbl);
20018
20019	if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
20020		printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
20021		       codec->chip_name);
20022		board_config = ALC680_AUTO;
20023	}
20024
20025	if (board_config == ALC680_AUTO) {
20026		/* automatic parse from the BIOS config */
20027		err = alc680_parse_auto_config(codec);
20028		if (err < 0) {
20029			alc_free(codec);
20030			return err;
20031		} else if (!err) {
20032			printk(KERN_INFO
20033			       "hda_codec: Cannot set up configuration "
20034			       "from BIOS.  Using base mode...\n");
20035			board_config = ALC680_BASE;
20036		}
20037	}
20038
20039	if (board_config != ALC680_AUTO)
20040		setup_preset(codec, &alc680_presets[board_config]);
20041
20042	spec->stream_analog_playback = &alc680_pcm_analog_playback;
20043	spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
20044	spec->stream_digital_playback = &alc680_pcm_digital_playback;
20045	spec->stream_digital_capture = &alc680_pcm_digital_capture;
20046
20047	if (!spec->adc_nids) {
20048		spec->adc_nids = alc680_adc_nids;
20049		spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
20050	}
20051
20052	if (!spec->cap_mixer)
20053		set_capture_mixer(codec);
20054
20055	spec->vmaster_nid = 0x02;
20056
20057	codec->patch_ops = alc_patch_ops;
20058	if (board_config == ALC680_AUTO)
20059		spec->init_hook = alc680_auto_init;
20060
20061	return 0;
20062}
20063
20064/*
20065 * patch entries
20066 */
20067static struct hda_codec_preset snd_hda_preset_realtek[] = {
20068	{ .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
20069	{ .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
20070	{ .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
20071	{ .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
20072	{ .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
20073	{ .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
20074	{ .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
20075	{ .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
20076	{ .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
20077	  .patch = patch_alc861 },
20078	{ .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
20079	{ .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
20080	{ .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
20081	{ .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
20082	  .patch = patch_alc882 },
20083	{ .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
20084	  .patch = patch_alc662 },
20085	{ .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
20086	{ .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
20087	{ .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
20088	{ .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
20089	{ .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
20090	{ .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
20091	{ .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
20092	{ .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
20093	  .patch = patch_alc882 },
20094	{ .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
20095	  .patch = patch_alc882 },
20096	{ .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
20097	{ .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc888 },
20098	{ .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
20099	  .patch = patch_alc882 },
20100	{ .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
20101	{ .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
20102	{ .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
20103	{} /* terminator */
20104};
20105
20106MODULE_ALIAS("snd-hda-codec-id:10ec*");
20107
20108MODULE_LICENSE("GPL");
20109MODULE_DESCRIPTION("Realtek HD-audio codec");
20110
20111static struct hda_codec_preset_list realtek_list = {
20112	.preset = snd_hda_preset_realtek,
20113	.owner = THIS_MODULE,
20114};
20115
20116static int __init patch_realtek_init(void)
20117{
20118	return snd_hda_add_codec_preset(&realtek_list);
20119}
20120
20121static void __exit patch_realtek_exit(void)
20122{
20123	snd_hda_delete_codec_preset(&realtek_list);
20124}
20125
20126module_init(patch_realtek_init)
20127module_exit(patch_realtek_exit)
20128