98b9f16c26ffa633d016294e1c47f63f073d3408
[linux-2.6.git] / sound / pci / hda / patch_realtek.c
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 <sound/driver.h>
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/slab.h>
30 #include <linux/pci.h>
31 #include <sound/core.h>
32 #include "hda_codec.h"
33 #include "hda_local.h"
34
35
36 /* ALC880 board config type */
37 enum {
38         ALC880_3ST,
39         ALC880_3ST_DIG,
40         ALC880_5ST,
41         ALC880_5ST_DIG,
42         ALC880_W810,
43         ALC880_Z71V,
44         ALC880_6ST,
45         ALC880_6ST_DIG,
46         ALC880_F1734,
47         ALC880_ASUS,
48         ALC880_ASUS_DIG,
49         ALC880_ASUS_W1V,
50         ALC880_ASUS_DIG2,
51         ALC880_UNIWILL_DIG,
52         ALC880_CLEVO,
53         ALC880_TCL_S700,
54         ALC880_LG,
55         ALC880_LG_LW,
56 #ifdef CONFIG_SND_DEBUG
57         ALC880_TEST,
58 #endif
59         ALC880_AUTO,
60         ALC880_MODEL_LAST /* last tag */
61 };
62
63 /* ALC260 models */
64 enum {
65         ALC260_BASIC,
66         ALC260_HP,
67         ALC260_HP_3013,
68         ALC260_FUJITSU_S702X,
69         ALC260_ACER,
70 #ifdef CONFIG_SND_DEBUG
71         ALC260_TEST,
72 #endif
73         ALC260_AUTO,
74         ALC260_MODEL_LAST /* last tag */
75 };
76
77 /* ALC262 models */
78 enum {
79         ALC262_BASIC,
80         ALC262_FUJITSU,
81         ALC262_AUTO,
82         ALC262_MODEL_LAST /* last tag */
83 };
84
85 /* ALC861 models */
86 enum {
87         ALC861_3ST,
88         ALC861_3ST_DIG,
89         ALC861_6ST_DIG,
90         ALC861_AUTO,
91         ALC861_MODEL_LAST,
92 };
93
94 /* ALC882 models */
95 enum {
96         ALC882_3ST_DIG,
97         ALC882_6ST_DIG,
98         ALC882_AUTO,
99         ALC882_MODEL_LAST,
100 };
101
102 /* for GPIO Poll */
103 #define GPIO_MASK       0x03
104
105 struct alc_spec {
106         /* codec parameterization */
107         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
108         unsigned int num_mixers;
109
110         const struct hda_verb *init_verbs[5];   /* initialization verbs
111                                                  * don't forget NULL termination!
112                                                  */
113         unsigned int num_init_verbs;
114
115         char *stream_name_analog;       /* analog PCM stream */
116         struct hda_pcm_stream *stream_analog_playback;
117         struct hda_pcm_stream *stream_analog_capture;
118
119         char *stream_name_digital;      /* digital PCM stream */ 
120         struct hda_pcm_stream *stream_digital_playback;
121         struct hda_pcm_stream *stream_digital_capture;
122
123         /* playback */
124         struct hda_multi_out multiout;  /* playback set-up
125                                          * max_channels, dacs must be set
126                                          * dig_out_nid and hp_nid are optional
127                                          */
128
129         /* capture */
130         unsigned int num_adc_nids;
131         hda_nid_t *adc_nids;
132         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
133
134         /* capture source */
135         unsigned int num_mux_defs;
136         const struct hda_input_mux *input_mux;
137         unsigned int cur_mux[3];
138
139         /* channel model */
140         const struct hda_channel_mode *channel_mode;
141         int num_channel_mode;
142
143         /* PCM information */
144         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
145
146         /* dynamic controls, init_verbs and input_mux */
147         struct auto_pin_cfg autocfg;
148         unsigned int num_kctl_alloc, num_kctl_used;
149         struct snd_kcontrol_new *kctl_alloc;
150         struct hda_input_mux private_imux;
151         hda_nid_t private_dac_nids[5];
152
153         /* hooks */
154         void (*init_hook)(struct hda_codec *codec);
155         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
156
157         /* for pin sensing */
158         unsigned int sense_updated: 1;
159         unsigned int jack_present: 1;
160 };
161
162 /*
163  * configuration template - to be copied to the spec instance
164  */
165 struct alc_config_preset {
166         struct snd_kcontrol_new *mixers[5]; /* should be identical size with spec */
167         const struct hda_verb *init_verbs[5];
168         unsigned int num_dacs;
169         hda_nid_t *dac_nids;
170         hda_nid_t dig_out_nid;          /* optional */
171         hda_nid_t hp_nid;               /* optional */
172         unsigned int num_adc_nids;
173         hda_nid_t *adc_nids;
174         hda_nid_t dig_in_nid;
175         unsigned int num_channel_mode;
176         const struct hda_channel_mode *channel_mode;
177         unsigned int num_mux_defs;
178         const struct hda_input_mux *input_mux;
179         void (*unsol_event)(struct hda_codec *, unsigned int);
180         void (*init_hook)(struct hda_codec *);
181 };
182
183
184 /*
185  * input MUX handling
186  */
187 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
188 {
189         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
190         struct alc_spec *spec = codec->spec;
191         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
192         if (mux_idx >= spec->num_mux_defs)
193                 mux_idx = 0;
194         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
195 }
196
197 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
198 {
199         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
200         struct alc_spec *spec = codec->spec;
201         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
202
203         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
204         return 0;
205 }
206
207 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
208 {
209         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
210         struct alc_spec *spec = codec->spec;
211         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
212         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
213         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
214                                      spec->adc_nids[adc_idx], &spec->cur_mux[adc_idx]);
215 }
216
217
218 /*
219  * channel mode setting
220  */
221 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
222 {
223         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
224         struct alc_spec *spec = codec->spec;
225         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
226                                     spec->num_channel_mode);
227 }
228
229 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
230 {
231         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
232         struct alc_spec *spec = codec->spec;
233         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
234                                    spec->num_channel_mode, spec->multiout.max_channels);
235 }
236
237 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
238 {
239         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
240         struct alc_spec *spec = codec->spec;
241         return snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
242                                    spec->num_channel_mode, &spec->multiout.max_channels);
243 }
244
245 /*
246  * Control the mode of pin widget settings via the mixer.  "pc" is used
247  * instead of "%" to avoid consequences of accidently treating the % as 
248  * being part of a format specifier.  Maximum allowed length of a value is
249  * 63 characters plus NULL terminator.
250  *
251  * Note: some retasking pin complexes seem to ignore requests for input
252  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
253  * are requested.  Therefore order this list so that this behaviour will not
254  * cause problems when mixer clients move through the enum sequentially.
255  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
256  * March 2006.
257  */
258 static char *alc_pin_mode_names[] = {
259         "Mic 50pc bias", "Mic 80pc bias",
260         "Line in", "Line out", "Headphone out",
261 };
262 static unsigned char alc_pin_mode_values[] = {
263         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
264 };
265 /* The control can present all 5 options, or it can limit the options based
266  * in the pin being assumed to be exclusively an input or an output pin.  In
267  * addition, "input" pins may or may not process the mic bias option
268  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
269  * accept requests for bias as of chip versions up to March 2006) and/or
270  * wiring in the computer.
271  */
272 #define ALC_PIN_DIR_IN              0x00
273 #define ALC_PIN_DIR_OUT             0x01
274 #define ALC_PIN_DIR_INOUT           0x02
275 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
276 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
277
278 /* Info about the pin modes supported by the different pin direction modes. 
279  * For each direction the minimum and maximum values are given.
280  */
281 static signed char alc_pin_mode_dir_info[5][2] = {
282         { 0, 2 },    /* ALC_PIN_DIR_IN */
283         { 3, 4 },    /* ALC_PIN_DIR_OUT */
284         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
285         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
286         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
287 };
288 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
289 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
290 #define alc_pin_mode_n_items(_dir) \
291         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
292
293 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
294 {
295         unsigned int item_num = uinfo->value.enumerated.item;
296         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
297
298         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
299         uinfo->count = 1;
300         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
301
302         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
303                 item_num = alc_pin_mode_min(dir);
304         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
305         return 0;
306 }
307
308 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
309 {
310         unsigned int i;
311         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
312         hda_nid_t nid = kcontrol->private_value & 0xffff;
313         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
314         long *valp = ucontrol->value.integer.value;
315         unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
316
317         /* Find enumerated value for current pinctl setting */
318         i = alc_pin_mode_min(dir);
319         while (alc_pin_mode_values[i]!=pinctl && i<=alc_pin_mode_max(dir))
320                 i++;
321         *valp = i<=alc_pin_mode_max(dir)?i:alc_pin_mode_min(dir);
322         return 0;
323 }
324
325 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
326 {
327         signed int change;
328         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
329         hda_nid_t nid = kcontrol->private_value & 0xffff;
330         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
331         long val = *ucontrol->value.integer.value;
332         unsigned int pinctl = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_PIN_WIDGET_CONTROL,0x00);
333
334         if (val<alc_pin_mode_min(dir) || val>alc_pin_mode_max(dir)) 
335                 val = alc_pin_mode_min(dir);
336
337         change = pinctl != alc_pin_mode_values[val];
338         if (change) {
339                 /* Set pin mode to that requested */
340                 snd_hda_codec_write(codec,nid,0,AC_VERB_SET_PIN_WIDGET_CONTROL,
341                         alc_pin_mode_values[val]);
342
343                 /* Also enable the retasking pin's input/output as required 
344                  * for the requested pin mode.  Enum values of 2 or less are
345                  * input modes.
346                  *
347                  * Dynamically switching the input/output buffers probably
348                  * reduces noise slightly (particularly on input) so we'll
349                  * do it.  However, having both input and output buffers
350                  * enabled simultaneously doesn't seem to be problematic if
351                  * this turns out to be necessary in the future.
352                  */
353                 if (val <= 2) {
354                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
355                                 AMP_OUT_MUTE);
356                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
357                                 AMP_IN_UNMUTE(0));
358                 } else {
359                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
360                                 AMP_IN_MUTE(0));
361                         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_AMP_GAIN_MUTE,
362                                 AMP_OUT_UNMUTE);
363                 }
364         }
365         return change;
366 }
367
368 #define ALC_PIN_MODE(xname, nid, dir) \
369         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
370           .info = alc_pin_mode_info, \
371           .get = alc_pin_mode_get, \
372           .put = alc_pin_mode_put, \
373           .private_value = nid | (dir<<16) }
374
375 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
376  * together using a mask with more than one bit set.  This control is
377  * currently used only by the ALC260 test model.  At this stage they are not
378  * needed for any "production" models.
379  */
380 #ifdef CONFIG_SND_DEBUG
381 static int alc_gpio_data_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
382 {
383         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
384         uinfo->count = 1;
385         uinfo->value.integer.min = 0;
386         uinfo->value.integer.max = 1;
387         return 0;
388 }                                
389 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
390 {
391         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
392         hda_nid_t nid = kcontrol->private_value & 0xffff;
393         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
394         long *valp = ucontrol->value.integer.value;
395         unsigned int val = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_GPIO_DATA,0x00);
396
397         *valp = (val & mask) != 0;
398         return 0;
399 }
400 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
401 {
402         signed int change;
403         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
404         hda_nid_t nid = kcontrol->private_value & 0xffff;
405         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
406         long val = *ucontrol->value.integer.value;
407         unsigned int gpio_data = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_GPIO_DATA,0x00);
408
409         /* Set/unset the masked GPIO bit(s) as needed */
410         change = (val==0?0:mask) != (gpio_data & mask);
411         if (val==0)
412                 gpio_data &= ~mask;
413         else
414                 gpio_data |= mask;
415         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_GPIO_DATA,gpio_data);
416
417         return change;
418 }
419 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
420         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
421           .info = alc_gpio_data_info, \
422           .get = alc_gpio_data_get, \
423           .put = alc_gpio_data_put, \
424           .private_value = nid | (mask<<16) }
425 #endif   /* CONFIG_SND_DEBUG */
426
427 /* A switch control to allow the enabling of the digital IO pins on the
428  * ALC260.  This is incredibly simplistic; the intention of this control is
429  * to provide something in the test model allowing digital outputs to be
430  * identified if present.  If models are found which can utilise these
431  * outputs a more complete mixer control can be devised for those models if
432  * necessary.
433  */
434 #ifdef CONFIG_SND_DEBUG
435 static int alc_spdif_ctrl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
436 {
437         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
438         uinfo->count = 1;
439         uinfo->value.integer.min = 0;
440         uinfo->value.integer.max = 1;
441         return 0;
442 }                                
443 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
444 {
445         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
446         hda_nid_t nid = kcontrol->private_value & 0xffff;
447         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
448         long *valp = ucontrol->value.integer.value;
449         unsigned int val = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_DIGI_CONVERT,0x00);
450
451         *valp = (val & mask) != 0;
452         return 0;
453 }
454 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
455 {
456         signed int change;
457         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
458         hda_nid_t nid = kcontrol->private_value & 0xffff;
459         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
460         long val = *ucontrol->value.integer.value;
461         unsigned int ctrl_data = snd_hda_codec_read(codec,nid,0,AC_VERB_GET_DIGI_CONVERT,0x00);
462
463         /* Set/unset the masked control bit(s) as needed */
464         change = (val==0?0:mask) != (ctrl_data & mask);
465         if (val==0)
466                 ctrl_data &= ~mask;
467         else
468                 ctrl_data |= mask;
469         snd_hda_codec_write(codec,nid,0,AC_VERB_SET_DIGI_CONVERT_1,ctrl_data);
470
471         return change;
472 }
473 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
474         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
475           .info = alc_spdif_ctrl_info, \
476           .get = alc_spdif_ctrl_get, \
477           .put = alc_spdif_ctrl_put, \
478           .private_value = nid | (mask<<16) }
479 #endif   /* CONFIG_SND_DEBUG */
480
481 /*
482  * set up from the preset table
483  */
484 static void setup_preset(struct alc_spec *spec, const struct alc_config_preset *preset)
485 {
486         int i;
487
488         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
489                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
490         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i]; i++)
491                 spec->init_verbs[spec->num_init_verbs++] = preset->init_verbs[i];
492         
493         spec->channel_mode = preset->channel_mode;
494         spec->num_channel_mode = preset->num_channel_mode;
495
496         spec->multiout.max_channels = spec->channel_mode[0].channels;
497
498         spec->multiout.num_dacs = preset->num_dacs;
499         spec->multiout.dac_nids = preset->dac_nids;
500         spec->multiout.dig_out_nid = preset->dig_out_nid;
501         spec->multiout.hp_nid = preset->hp_nid;
502         
503         spec->num_mux_defs = preset->num_mux_defs;
504         if (! spec->num_mux_defs)
505                 spec->num_mux_defs = 1;
506         spec->input_mux = preset->input_mux;
507
508         spec->num_adc_nids = preset->num_adc_nids;
509         spec->adc_nids = preset->adc_nids;
510         spec->dig_in_nid = preset->dig_in_nid;
511
512         spec->unsol_event = preset->unsol_event;
513         spec->init_hook = preset->init_hook;
514 }
515
516 /*
517  * ALC880 3-stack model
518  *
519  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
520  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18, F-Mic = 0x1b
521  *                 HP = 0x19
522  */
523
524 static hda_nid_t alc880_dac_nids[4] = {
525         /* front, rear, clfe, rear_surr */
526         0x02, 0x05, 0x04, 0x03
527 };
528
529 static hda_nid_t alc880_adc_nids[3] = {
530         /* ADC0-2 */
531         0x07, 0x08, 0x09,
532 };
533
534 /* The datasheet says the node 0x07 is connected from inputs,
535  * but it shows zero connection in the real implementation on some devices.
536  * Note: this is a 915GAV bug, fixed on 915GLV
537  */
538 static hda_nid_t alc880_adc_nids_alt[2] = {
539         /* ADC1-2 */
540         0x08, 0x09,
541 };
542
543 #define ALC880_DIGOUT_NID       0x06
544 #define ALC880_DIGIN_NID        0x0a
545
546 static struct hda_input_mux alc880_capture_source = {
547         .num_items = 4,
548         .items = {
549                 { "Mic", 0x0 },
550                 { "Front Mic", 0x3 },
551                 { "Line", 0x2 },
552                 { "CD", 0x4 },
553         },
554 };
555
556 /* channel source setting (2/6 channel selection for 3-stack) */
557 /* 2ch mode */
558 static struct hda_verb alc880_threestack_ch2_init[] = {
559         /* set line-in to input, mute it */
560         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
561         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
562         /* set mic-in to input vref 80%, mute it */
563         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
564         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
565         { } /* end */
566 };
567
568 /* 6ch mode */
569 static struct hda_verb alc880_threestack_ch6_init[] = {
570         /* set line-in to output, unmute it */
571         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
572         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
573         /* set mic-in to output, unmute it */
574         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
575         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
576         { } /* end */
577 };
578
579 static struct hda_channel_mode alc880_threestack_modes[2] = {
580         { 2, alc880_threestack_ch2_init },
581         { 6, alc880_threestack_ch6_init },
582 };
583
584 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
585         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
586         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
587         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
588         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
589         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
590         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
591         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
592         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
593         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
594         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
595         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
596         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
597         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
598         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
599         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
600         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
601         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
602         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
603         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
604         {
605                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
606                 .name = "Channel Mode",
607                 .info = alc_ch_mode_info,
608                 .get = alc_ch_mode_get,
609                 .put = alc_ch_mode_put,
610         },
611         { } /* end */
612 };
613
614 /* capture mixer elements */
615 static struct snd_kcontrol_new alc880_capture_mixer[] = {
616         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
617         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
618         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
619         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
620         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
621         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
622         {
623                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
624                 /* The multiple "Capture Source" controls confuse alsamixer
625                  * So call somewhat different..
626                  * FIXME: the controls appear in the "playback" view!
627                  */
628                 /* .name = "Capture Source", */
629                 .name = "Input Source",
630                 .count = 3,
631                 .info = alc_mux_enum_info,
632                 .get = alc_mux_enum_get,
633                 .put = alc_mux_enum_put,
634         },
635         { } /* end */
636 };
637
638 /* capture mixer elements (in case NID 0x07 not available) */
639 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
640         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
641         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
642         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
643         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
644         {
645                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
646                 /* The multiple "Capture Source" controls confuse alsamixer
647                  * So call somewhat different..
648                  * FIXME: the controls appear in the "playback" view!
649                  */
650                 /* .name = "Capture Source", */
651                 .name = "Input Source",
652                 .count = 2,
653                 .info = alc_mux_enum_info,
654                 .get = alc_mux_enum_get,
655                 .put = alc_mux_enum_put,
656         },
657         { } /* end */
658 };
659
660
661
662 /*
663  * ALC880 5-stack model
664  *
665  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d), Side = 0x02 (0xd)
666  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
667  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
668  */
669
670 /* additional mixers to alc880_three_stack_mixer */
671 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
672         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
673         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
674         { } /* end */
675 };
676
677 /* channel source setting (6/8 channel selection for 5-stack) */
678 /* 6ch mode */
679 static struct hda_verb alc880_fivestack_ch6_init[] = {
680         /* set line-in to input, mute it */
681         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
682         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
683         { } /* end */
684 };
685
686 /* 8ch mode */
687 static struct hda_verb alc880_fivestack_ch8_init[] = {
688         /* set line-in to output, unmute it */
689         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
690         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
691         { } /* end */
692 };
693
694 static struct hda_channel_mode alc880_fivestack_modes[2] = {
695         { 6, alc880_fivestack_ch6_init },
696         { 8, alc880_fivestack_ch8_init },
697 };
698
699
700 /*
701  * ALC880 6-stack model
702  *
703  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e), Side = 0x05 (0x0f)
704  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
705  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
706  */
707
708 static hda_nid_t alc880_6st_dac_nids[4] = {
709         /* front, rear, clfe, rear_surr */
710         0x02, 0x03, 0x04, 0x05
711 };      
712
713 static struct hda_input_mux alc880_6stack_capture_source = {
714         .num_items = 4,
715         .items = {
716                 { "Mic", 0x0 },
717                 { "Front Mic", 0x1 },
718                 { "Line", 0x2 },
719                 { "CD", 0x4 },
720         },
721 };
722
723 /* fixed 8-channels */
724 static struct hda_channel_mode alc880_sixstack_modes[1] = {
725         { 8, NULL },
726 };
727
728 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
729         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
730         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
731         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
732         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
733         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
734         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
735         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
736         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
737         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
738         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
739         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
740         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
741         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
742         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
743         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
744         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
745         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
746         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
747         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
748         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
749         {
750                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
751                 .name = "Channel Mode",
752                 .info = alc_ch_mode_info,
753                 .get = alc_ch_mode_get,
754                 .put = alc_ch_mode_put,
755         },
756         { } /* end */
757 };
758
759
760 /*
761  * ALC880 W810 model
762  *
763  * W810 has rear IO for:
764  * Front (DAC 02)
765  * Surround (DAC 03)
766  * Center/LFE (DAC 04)
767  * Digital out (06)
768  *
769  * The system also has a pair of internal speakers, and a headphone jack.
770  * These are both connected to Line2 on the codec, hence to DAC 02.
771  * 
772  * There is a variable resistor to control the speaker or headphone
773  * volume. This is a hardware-only device without a software API.
774  *
775  * Plugging headphones in will disable the internal speakers. This is
776  * implemented in hardware, not via the driver using jack sense. In
777  * a similar fashion, plugging into the rear socket marked "front" will
778  * disable both the speakers and headphones.
779  *
780  * For input, there's a microphone jack, and an "audio in" jack.
781  * These may not do anything useful with this driver yet, because I
782  * haven't setup any initialization verbs for these yet...
783  */
784
785 static hda_nid_t alc880_w810_dac_nids[3] = {
786         /* front, rear/surround, clfe */
787         0x02, 0x03, 0x04
788 };
789
790 /* fixed 6 channels */
791 static struct hda_channel_mode alc880_w810_modes[1] = {
792         { 6, NULL }
793 };
794
795 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
796 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
797         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
798         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
799         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
800         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
801         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
802         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
803         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
804         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
805         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
806         { } /* end */
807 };
808
809
810 /*
811  * Z710V model
812  *
813  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
814  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?), Line = 0x1a
815  */
816
817 static hda_nid_t alc880_z71v_dac_nids[1] = {
818         0x02
819 };
820 #define ALC880_Z71V_HP_DAC      0x03
821
822 /* fixed 2 channels */
823 static struct hda_channel_mode alc880_2_jack_modes[1] = {
824         { 2, NULL }
825 };
826
827 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
828         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
829         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
830         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
831         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
832         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
833         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
834         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
835         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
836         { } /* end */
837 };
838
839
840 /* FIXME! */
841 /*
842  * ALC880 F1734 model
843  *
844  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
845  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
846  */
847
848 static hda_nid_t alc880_f1734_dac_nids[1] = {
849         0x03
850 };
851 #define ALC880_F1734_HP_DAC     0x02
852
853 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
854         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
855         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
856         HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
857         HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
858         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
859         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
860         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
861         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
862         { } /* end */
863 };
864
865
866 /* FIXME! */
867 /*
868  * ALC880 ASUS model
869  *
870  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
871  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
872  *  Mic = 0x18, Line = 0x1a
873  */
874
875 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
876 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
877
878 static struct snd_kcontrol_new alc880_asus_mixer[] = {
879         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
880         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
881         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
882         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
883         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
884         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
885         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
886         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
887         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
888         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
889         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
890         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
893         {
894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
895                 .name = "Channel Mode",
896                 .info = alc_ch_mode_info,
897                 .get = alc_ch_mode_get,
898                 .put = alc_ch_mode_put,
899         },
900         { } /* end */
901 };
902
903 /* FIXME! */
904 /*
905  * ALC880 ASUS W1V model
906  *
907  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
908  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
909  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
910  */
911
912 /* additional mixers to alc880_asus_mixer */
913 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
914         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
915         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
916         { } /* end */
917 };
918
919 /* additional mixers to alc880_asus_mixer */
920 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
921         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
922         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
923         { } /* end */
924 };
925
926 /* TCL S700 */
927 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
928         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
929         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
930         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
931         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
932         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
933         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
934         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
935         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
936         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
937         {
938                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
939                 /* The multiple "Capture Source" controls confuse alsamixer
940                  * So call somewhat different..
941                  * FIXME: the controls appear in the "playback" view!
942                  */
943                 /* .name = "Capture Source", */
944                 .name = "Input Source",
945                 .count = 1,
946                 .info = alc_mux_enum_info,
947                 .get = alc_mux_enum_get,
948                 .put = alc_mux_enum_put,
949         },
950         { } /* end */
951 };
952
953 /*
954  * build control elements
955  */
956 static int alc_build_controls(struct hda_codec *codec)
957 {
958         struct alc_spec *spec = codec->spec;
959         int err;
960         int i;
961
962         for (i = 0; i < spec->num_mixers; i++) {
963                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
964                 if (err < 0)
965                         return err;
966         }
967
968         if (spec->multiout.dig_out_nid) {
969                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
970                 if (err < 0)
971                         return err;
972         }
973         if (spec->dig_in_nid) {
974                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
975                 if (err < 0)
976                         return err;
977         }
978         return 0;
979 }
980
981
982 /*
983  * initialize the codec volumes, etc
984  */
985
986 /*
987  * generic initialization of ADC, input mixers and output mixers
988  */
989 static struct hda_verb alc880_volume_init_verbs[] = {
990         /*
991          * Unmute ADC0-2 and set the default input to mic-in
992          */
993         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
994         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
995         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
996         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
997         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
998         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
999
1000         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1001          * mixer widget
1002          * Note: PASD motherboards uses the Line In 2 as the input for front panel
1003          * mic (mic 2)
1004          */
1005         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
1006         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1007         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1008         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1009         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1010         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1011
1012         /*
1013          * Set up output mixers (0x0c - 0x0f)
1014          */
1015         /* set vol=0 to output mixers */
1016         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1017         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1018         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1019         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1020         /* set up input amps for analog loopback */
1021         /* Amp Indices: DAC = 0, mixer = 1 */
1022         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1023         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1024         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1025         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1026         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1027         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1028         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
1029         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
1030
1031         { }
1032 };
1033
1034 /*
1035  * 3-stack pin configuration:
1036  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
1037  */
1038 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
1039         /*
1040          * preset connection lists of input pins
1041          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1042          */
1043         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
1044         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1045         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
1046
1047         /*
1048          * Set pin mode and muting
1049          */
1050         /* set front pin widgets 0x14 for output */
1051         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1052         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1053         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1054         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1055         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1056         /* Mic2 (as headphone out) for HP output */
1057         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1058         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1059         /* Line In pin widget for input */
1060         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1061         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1062         /* Line2 (as front mic) pin widget for input and vref at 80% */
1063         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1064         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1065         /* CD pin widget for input */
1066         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1067
1068         { }
1069 };
1070
1071 /*
1072  * 5-stack pin configuration:
1073  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
1074  * line-in/side = 0x1a, f-mic = 0x1b
1075  */
1076 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
1077         /*
1078          * preset connection lists of input pins
1079          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
1080          */
1081         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1082         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
1083
1084         /*
1085          * Set pin mode and muting
1086          */
1087         /* set pin widgets 0x14-0x17 for output */
1088         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1089         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1090         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1091         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1092         /* unmute pins for output (no gain on this amp) */
1093         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1094         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1095         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1096         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1097
1098         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1099         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1100         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1101         /* Mic2 (as headphone out) for HP output */
1102         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1103         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1104         /* Line In pin widget for input */
1105         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1106         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1107         /* Line2 (as front mic) pin widget for input and vref at 80% */
1108         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1109         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1110         /* CD pin widget for input */
1111         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1112
1113         { }
1114 };
1115
1116 /*
1117  * W810 pin configuration:
1118  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
1119  */
1120 static struct hda_verb alc880_pin_w810_init_verbs[] = {
1121         /* hphone/speaker input selector: front DAC */
1122         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
1123
1124         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1125         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1126         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1127         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1128         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1129         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1130
1131         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1132         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1133
1134         { }
1135 };
1136
1137 /*
1138  * Z71V pin configuration:
1139  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
1140  */
1141 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
1142         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1143         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1144         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1145         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1146
1147         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1148         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1149         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1150         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1151
1152         { }
1153 };
1154
1155 /*
1156  * 6-stack pin configuration:
1157  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18, f-mic = 0x19,
1158  * line = 0x1a, HP = 0x1b
1159  */
1160 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
1161         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
1162
1163         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1164         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1165         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1166         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1167         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1168         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1169         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1170         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1171
1172         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1173         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1174         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1175         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1176         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1177         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1178         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1179         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1180         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1181         
1182         { }
1183 };
1184
1185 /* FIXME! */
1186 /*
1187  * F1734 pin configuration:
1188  * HP = 0x14, speaker-out = 0x15, mic = 0x18
1189  */
1190 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
1191         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1192         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1193         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1194         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1195
1196         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1197         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1198         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1199         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1200
1201         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1202         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1203         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1204         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1205         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1206         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1207         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1208         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1209         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1210
1211         { }
1212 };
1213
1214 /* FIXME! */
1215 /*
1216  * ASUS pin configuration:
1217  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
1218  */
1219 static struct hda_verb alc880_pin_asus_init_verbs[] = {
1220         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
1221         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
1222         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
1223         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1224
1225         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1226         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1227         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1228         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1229         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1230         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1231         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1232         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1233
1234         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1235         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1236         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1237         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1238         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1239         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
1240         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1241         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1242         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1243         
1244         { }
1245 };
1246
1247 /* Enable GPIO mask and set output */
1248 static struct hda_verb alc880_gpio1_init_verbs[] = {
1249         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
1250         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
1251         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
1252
1253         { }
1254 };
1255
1256 /* Enable GPIO mask and set output */
1257 static struct hda_verb alc880_gpio2_init_verbs[] = {
1258         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
1259         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
1260         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
1261
1262         { }
1263 };
1264
1265 /* Clevo m520g init */
1266 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
1267         /* headphone output */
1268         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1269         /* line-out */
1270         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1271         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1272         /* Line-in */
1273         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1274         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1275         /* CD */
1276         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1277         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1278         /* Mic1 (rear panel) */
1279         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1280         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1281         /* Mic2 (front panel) */
1282         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1283         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1284         /* headphone */
1285         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1286         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1287         /* change to EAPD mode */
1288         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1289         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
1290
1291         { }
1292 };
1293
1294 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
1295         /* Headphone output */
1296         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1297         /* Front output*/
1298         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1299         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1300
1301         /* Line In pin widget for input */
1302         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1303         /* CD pin widget for input */
1304         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1305         /* Mic1 (rear panel) pin widget for input and vref at 80% */
1306         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1307
1308         /* change to EAPD mode */
1309         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
1310         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
1311
1312         { }
1313 };
1314
1315 /*
1316  * LG m1 express dual
1317  *
1318  * Pin assignment:
1319  *   Rear Line-In/Out (blue): 0x14
1320  *   Build-in Mic-In: 0x15
1321  *   Speaker-out: 0x17
1322  *   HP-Out (green): 0x1b
1323  *   Mic-In/Out (red): 0x19
1324  *   SPDIF-Out: 0x1e
1325  */
1326
1327 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
1328 static hda_nid_t alc880_lg_dac_nids[3] = {
1329         0x05, 0x02, 0x03
1330 };
1331
1332 /* seems analog CD is not working */
1333 static struct hda_input_mux alc880_lg_capture_source = {
1334         .num_items = 3,
1335         .items = {
1336                 { "Mic", 0x1 },
1337                 { "Line", 0x5 },
1338                 { "Internal Mic", 0x6 },
1339         },
1340 };
1341
1342 /* 2,4,6 channel modes */
1343 static struct hda_verb alc880_lg_ch2_init[] = {
1344         /* set line-in and mic-in to input */
1345         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1346         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1347         { }
1348 };
1349
1350 static struct hda_verb alc880_lg_ch4_init[] = {
1351         /* set line-in to out and mic-in to input */
1352         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1353         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1354         { }
1355 };
1356
1357 static struct hda_verb alc880_lg_ch6_init[] = {
1358         /* set line-in and mic-in to output */
1359         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1360         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
1361         { }
1362 };
1363
1364 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
1365         { 2, alc880_lg_ch2_init },
1366         { 4, alc880_lg_ch4_init },
1367         { 6, alc880_lg_ch6_init },
1368 };
1369
1370 static struct snd_kcontrol_new alc880_lg_mixer[] = {
1371         /* FIXME: it's not really "master" but front channels */
1372         HDA_CODEC_VOLUME("Master Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1373         HDA_BIND_MUTE("Master Playback Switch", 0x0f, 2, HDA_INPUT),
1374         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1375         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
1376         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1377         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
1378         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
1379         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
1380         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1381         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1382         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
1383         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
1384         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
1385         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
1386         {
1387                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1388                 .name = "Channel Mode",
1389                 .info = alc_ch_mode_info,
1390                 .get = alc_ch_mode_get,
1391                 .put = alc_ch_mode_put,
1392         },
1393         { } /* end */
1394 };
1395
1396 static struct hda_verb alc880_lg_init_verbs[] = {
1397         /* set capture source to mic-in */
1398         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1399         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1400         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1401         /* mute all amp mixer inputs */
1402         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
1403         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(6)},
1404         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
1405         /* line-in to input */
1406         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1407         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1408         /* built-in mic */
1409         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1410         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1411         /* speaker-out */
1412         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1413         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1414         /* mic-in to input */
1415         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
1416         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1417         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1418         /* HP-out */
1419         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
1420         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1421         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1422         /* jack sense */
1423         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
1424         { }
1425 };
1426
1427 /* toggle speaker-output according to the hp-jack state */
1428 static void alc880_lg_automute(struct hda_codec *codec)
1429 {
1430         unsigned int present;
1431
1432         present = snd_hda_codec_read(codec, 0x1b, 0,
1433                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1434         snd_hda_codec_amp_update(codec, 0x17, 0, HDA_OUTPUT, 0,
1435                                  0x80, present ? 0x80 : 0);
1436         snd_hda_codec_amp_update(codec, 0x17, 1, HDA_OUTPUT, 0,
1437                                  0x80, present ? 0x80 : 0);
1438 }
1439
1440 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
1441 {
1442         /* Looks like the unsol event is incompatible with the standard
1443          * definition.  4bit tag is placed at 28 bit!
1444          */
1445         if ((res >> 28) == 0x01)
1446                 alc880_lg_automute(codec);
1447 }
1448
1449 /*
1450  * LG LW20
1451  *
1452  * Pin assignment:
1453  *   Speaker-out: 0x14
1454  *   Mic-In: 0x18
1455  *   Built-in Mic-In: 0x19 (?)
1456  *   HP-Out: 0x1b
1457  *   SPDIF-Out: 0x1e
1458  */
1459
1460 /* seems analog CD is not working */
1461 static struct hda_input_mux alc880_lg_lw_capture_source = {
1462         .num_items = 2,
1463         .items = {
1464                 { "Mic", 0x0 },
1465                 { "Internal Mic", 0x1 },
1466         },
1467 };
1468
1469 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
1470         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1471         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
1472         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1473         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1474         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
1475         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
1476         { } /* end */
1477 };
1478
1479 static struct hda_verb alc880_lg_lw_init_verbs[] = {
1480         /* set capture source to mic-in */
1481         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1482         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1483         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1484         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(7)},
1485         /* speaker-out */
1486         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1487         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1488         /* HP-out */
1489         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
1490         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
1491         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1492         /* mic-in to input */
1493         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1494         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1495         /* built-in mic */
1496         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
1497         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1498         /* jack sense */
1499         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
1500         { }
1501 };
1502
1503 /* toggle speaker-output according to the hp-jack state */
1504 static void alc880_lg_lw_automute(struct hda_codec *codec)
1505 {
1506         unsigned int present;
1507
1508         present = snd_hda_codec_read(codec, 0x1b, 0,
1509                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1510         snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
1511                                  0x80, present ? 0x80 : 0);
1512         snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
1513                                  0x80, present ? 0x80 : 0);
1514 }
1515
1516 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
1517 {
1518         /* Looks like the unsol event is incompatible with the standard
1519          * definition.  4bit tag is placed at 28 bit!
1520          */
1521         if ((res >> 28) == 0x01)
1522                 alc880_lg_lw_automute(codec);
1523 }
1524
1525 /*
1526  * Common callbacks
1527  */
1528
1529 static int alc_init(struct hda_codec *codec)
1530 {
1531         struct alc_spec *spec = codec->spec;
1532         unsigned int i;
1533
1534         for (i = 0; i < spec->num_init_verbs; i++)
1535                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1536
1537         if (spec->init_hook)
1538                 spec->init_hook(codec);
1539
1540         return 0;
1541 }
1542
1543 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
1544 {
1545         struct alc_spec *spec = codec->spec;
1546
1547         if (spec->unsol_event)
1548                 spec->unsol_event(codec, res);
1549 }
1550
1551 #ifdef CONFIG_PM
1552 /*
1553  * resume
1554  */
1555 static int alc_resume(struct hda_codec *codec)
1556 {
1557         struct alc_spec *spec = codec->spec;
1558         int i;
1559
1560         alc_init(codec);
1561         for (i = 0; i < spec->num_mixers; i++)
1562                 snd_hda_resume_ctls(codec, spec->mixers[i]);
1563         if (spec->multiout.dig_out_nid)
1564                 snd_hda_resume_spdif_out(codec);
1565         if (spec->dig_in_nid)
1566                 snd_hda_resume_spdif_in(codec);
1567
1568         return 0;
1569 }
1570 #endif
1571
1572 /*
1573  * Analog playback callbacks
1574  */
1575 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
1576                                     struct hda_codec *codec,
1577                                     struct snd_pcm_substream *substream)
1578 {
1579         struct alc_spec *spec = codec->spec;
1580         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream);
1581 }
1582
1583 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1584                                        struct hda_codec *codec,
1585                                        unsigned int stream_tag,
1586                                        unsigned int format,
1587                                        struct snd_pcm_substream *substream)
1588 {
1589         struct alc_spec *spec = codec->spec;
1590         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1591                                                 format, substream);
1592 }
1593
1594 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1595                                        struct hda_codec *codec,
1596                                        struct snd_pcm_substream *substream)
1597 {
1598         struct alc_spec *spec = codec->spec;
1599         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1600 }
1601
1602 /*
1603  * Digital out
1604  */
1605 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1606                                         struct hda_codec *codec,
1607                                         struct snd_pcm_substream *substream)
1608 {
1609         struct alc_spec *spec = codec->spec;
1610         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1611 }
1612
1613 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1614                                          struct hda_codec *codec,
1615                                          struct snd_pcm_substream *substream)
1616 {
1617         struct alc_spec *spec = codec->spec;
1618         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1619 }
1620
1621 /*
1622  * Analog capture
1623  */
1624 static int alc880_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1625                                       struct hda_codec *codec,
1626                                       unsigned int stream_tag,
1627                                       unsigned int format,
1628                                       struct snd_pcm_substream *substream)
1629 {
1630         struct alc_spec *spec = codec->spec;
1631
1632         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1633                                    stream_tag, 0, format);
1634         return 0;
1635 }
1636
1637 static int alc880_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1638                                       struct hda_codec *codec,
1639                                       struct snd_pcm_substream *substream)
1640 {
1641         struct alc_spec *spec = codec->spec;
1642
1643         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 0, 0, 0);
1644         return 0;
1645 }
1646
1647
1648 /*
1649  */
1650 static struct hda_pcm_stream alc880_pcm_analog_playback = {
1651         .substreams = 1,
1652         .channels_min = 2,
1653         .channels_max = 8,
1654         /* NID is set in alc_build_pcms */
1655         .ops = {
1656                 .open = alc880_playback_pcm_open,
1657                 .prepare = alc880_playback_pcm_prepare,
1658                 .cleanup = alc880_playback_pcm_cleanup
1659         },
1660 };
1661
1662 static struct hda_pcm_stream alc880_pcm_analog_capture = {
1663         .substreams = 2,
1664         .channels_min = 2,
1665         .channels_max = 2,
1666         /* NID is set in alc_build_pcms */
1667         .ops = {
1668                 .prepare = alc880_capture_pcm_prepare,
1669                 .cleanup = alc880_capture_pcm_cleanup
1670         },
1671 };
1672
1673 static struct hda_pcm_stream alc880_pcm_digital_playback = {
1674         .substreams = 1,
1675         .channels_min = 2,
1676         .channels_max = 2,
1677         /* NID is set in alc_build_pcms */
1678         .ops = {
1679                 .open = alc880_dig_playback_pcm_open,
1680                 .close = alc880_dig_playback_pcm_close
1681         },
1682 };
1683
1684 static struct hda_pcm_stream alc880_pcm_digital_capture = {
1685         .substreams = 1,
1686         .channels_min = 2,
1687         .channels_max = 2,
1688         /* NID is set in alc_build_pcms */
1689 };
1690
1691 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
1692 static struct hda_pcm_stream alc_pcm_null_playback = {
1693         .substreams = 0,
1694         .channels_min = 0,
1695         .channels_max = 0,
1696 };
1697
1698 static int alc_build_pcms(struct hda_codec *codec)
1699 {
1700         struct alc_spec *spec = codec->spec;
1701         struct hda_pcm *info = spec->pcm_rec;
1702         int i;
1703
1704         codec->num_pcms = 1;
1705         codec->pcm_info = info;
1706
1707         info->name = spec->stream_name_analog;
1708         if (spec->stream_analog_playback) {
1709                 snd_assert(spec->multiout.dac_nids, return -EINVAL);
1710                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
1711                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
1712         }
1713         if (spec->stream_analog_capture) {
1714                 snd_assert(spec->adc_nids, return -EINVAL);
1715                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
1716                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1717         }
1718
1719         if (spec->channel_mode) {
1720                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
1721                 for (i = 0; i < spec->num_channel_mode; i++) {
1722                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
1723                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
1724                         }
1725                 }
1726         }
1727
1728         /* If the use of more than one ADC is requested for the current
1729          * model, configure a second analog capture-only PCM.
1730          */
1731         if (spec->num_adc_nids > 1) {
1732                 codec->num_pcms++;
1733                 info++;
1734                 info->name = spec->stream_name_analog;
1735                 /* No playback stream for second PCM */
1736                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = alc_pcm_null_playback;
1737                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
1738                 if (spec->stream_analog_capture) {
1739                         snd_assert(spec->adc_nids, return -EINVAL);
1740                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
1741                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[1];
1742                 }
1743         }
1744
1745         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1746                 codec->num_pcms++;
1747                 info++;
1748                 info->name = spec->stream_name_digital;
1749                 if (spec->multiout.dig_out_nid &&
1750                     spec->stream_digital_playback) {
1751                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
1752                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
1753                 }
1754                 if (spec->dig_in_nid &&
1755                     spec->stream_digital_capture) {
1756                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
1757                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
1758                 }
1759         }
1760
1761         return 0;
1762 }
1763
1764 static void alc_free(struct hda_codec *codec)
1765 {
1766         struct alc_spec *spec = codec->spec;
1767         unsigned int i;
1768
1769         if (! spec)
1770                 return;
1771
1772         if (spec->kctl_alloc) {
1773                 for (i = 0; i < spec->num_kctl_used; i++)
1774                         kfree(spec->kctl_alloc[i].name);
1775                 kfree(spec->kctl_alloc);
1776         }
1777         kfree(spec);
1778 }
1779
1780 /*
1781  */
1782 static struct hda_codec_ops alc_patch_ops = {
1783         .build_controls = alc_build_controls,
1784         .build_pcms = alc_build_pcms,
1785         .init = alc_init,
1786         .free = alc_free,
1787         .unsol_event = alc_unsol_event,
1788 #ifdef CONFIG_PM
1789         .resume = alc_resume,
1790 #endif
1791 };
1792
1793
1794 /*
1795  * Test configuration for debugging
1796  *
1797  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
1798  * enum controls.
1799  */
1800 #ifdef CONFIG_SND_DEBUG
1801 static hda_nid_t alc880_test_dac_nids[4] = {
1802         0x02, 0x03, 0x04, 0x05
1803 };
1804
1805 static struct hda_input_mux alc880_test_capture_source = {
1806         .num_items = 7,
1807         .items = {
1808                 { "In-1", 0x0 },
1809                 { "In-2", 0x1 },
1810                 { "In-3", 0x2 },
1811                 { "In-4", 0x3 },
1812                 { "CD", 0x4 },
1813                 { "Front", 0x5 },
1814                 { "Surround", 0x6 },
1815         },
1816 };
1817
1818 static struct hda_channel_mode alc880_test_modes[4] = {
1819         { 2, NULL },
1820         { 4, NULL },
1821         { 6, NULL },
1822         { 8, NULL },
1823 };
1824
1825 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1826 {
1827         static char *texts[] = {
1828                 "N/A", "Line Out", "HP Out",
1829                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
1830         };
1831         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1832         uinfo->count = 1;
1833         uinfo->value.enumerated.items = 8;
1834         if (uinfo->value.enumerated.item >= 8)
1835                 uinfo->value.enumerated.item = 7;
1836         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1837         return 0;
1838 }
1839
1840 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1841 {
1842         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1843         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1844         unsigned int pin_ctl, item = 0;
1845
1846         pin_ctl = snd_hda_codec_read(codec, nid, 0,
1847                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1848         if (pin_ctl & AC_PINCTL_OUT_EN) {
1849                 if (pin_ctl & AC_PINCTL_HP_EN)
1850                         item = 2;
1851                 else
1852                         item = 1;
1853         } else if (pin_ctl & AC_PINCTL_IN_EN) {
1854                 switch (pin_ctl & AC_PINCTL_VREFEN) {
1855                 case AC_PINCTL_VREF_HIZ: item = 3; break;
1856                 case AC_PINCTL_VREF_50:  item = 4; break;
1857                 case AC_PINCTL_VREF_GRD: item = 5; break;
1858                 case AC_PINCTL_VREF_80:  item = 6; break;
1859                 case AC_PINCTL_VREF_100: item = 7; break;
1860                 }
1861         }
1862         ucontrol->value.enumerated.item[0] = item;
1863         return 0;
1864 }
1865
1866 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1867 {
1868         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1869         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1870         static unsigned int ctls[] = {
1871                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
1872                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
1873                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
1874                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
1875                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
1876                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
1877         };
1878         unsigned int old_ctl, new_ctl;
1879
1880         old_ctl = snd_hda_codec_read(codec, nid, 0,
1881                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1882         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
1883         if (old_ctl != new_ctl) {
1884                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, new_ctl);
1885                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
1886                                     ucontrol->value.enumerated.item[0] >= 3 ? 0xb080 : 0xb000);
1887                 return 1;
1888         }
1889         return 0;
1890 }
1891
1892 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1893 {
1894         static char *texts[] = {
1895                 "Front", "Surround", "CLFE", "Side"
1896         };
1897         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1898         uinfo->count = 1;
1899         uinfo->value.enumerated.items = 4;
1900         if (uinfo->value.enumerated.item >= 4)
1901                 uinfo->value.enumerated.item = 3;
1902         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1903         return 0;
1904 }
1905
1906 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1907 {
1908         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1909         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1910         unsigned int sel;
1911
1912         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
1913         ucontrol->value.enumerated.item[0] = sel & 3;
1914         return 0;
1915 }
1916
1917 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1918 {
1919         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1920         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
1921         unsigned int sel;
1922
1923         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
1924         if (ucontrol->value.enumerated.item[0] != sel) {
1925                 sel = ucontrol->value.enumerated.item[0] & 3;
1926                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, sel);
1927                 return 1;
1928         }
1929         return 0;
1930 }
1931
1932 #define PIN_CTL_TEST(xname,nid) {                       \
1933                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
1934                         .name = xname,                 \
1935                         .info = alc_test_pin_ctl_info, \
1936                         .get = alc_test_pin_ctl_get,   \
1937                         .put = alc_test_pin_ctl_put,   \
1938                         .private_value = nid           \
1939                         }
1940
1941 #define PIN_SRC_TEST(xname,nid) {                       \
1942                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
1943                         .name = xname,                 \
1944                         .info = alc_test_pin_src_info, \
1945                         .get = alc_test_pin_src_get,   \
1946                         .put = alc_test_pin_src_put,   \
1947                         .private_value = nid           \
1948                         }
1949
1950 static struct snd_kcontrol_new alc880_test_mixer[] = {
1951         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1952         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1953         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
1954         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1955         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1956         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1957         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
1958         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1959         PIN_CTL_TEST("Front Pin Mode", 0x14),
1960         PIN_CTL_TEST("Surround Pin Mode", 0x15),
1961         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
1962         PIN_CTL_TEST("Side Pin Mode", 0x17),
1963         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
1964         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
1965         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
1966         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
1967         PIN_SRC_TEST("In-1 Pin Source", 0x18),
1968         PIN_SRC_TEST("In-2 Pin Source", 0x19),
1969         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
1970         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
1971         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
1972         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
1973         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
1974         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
1975         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
1976         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
1977         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
1978         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
1979         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
1980         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
1981         {
1982                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1983                 .name = "Channel Mode",
1984                 .info = alc_ch_mode_info,
1985                 .get = alc_ch_mode_get,
1986                 .put = alc_ch_mode_put,
1987         },
1988         { } /* end */
1989 };
1990
1991 static struct hda_verb alc880_test_init_verbs[] = {
1992         /* Unmute inputs of 0x0c - 0x0f */
1993         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1994         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1995         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1996         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1997         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1998         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1999         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2000         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2001         /* Vol output for 0x0c-0x0f */
2002         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2003         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2004         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2005         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2006         /* Set output pins 0x14-0x17 */
2007         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2008         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2009         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2010         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2011         /* Unmute output pins 0x14-0x17 */
2012         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2013         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2014         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2015         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2016         /* Set input pins 0x18-0x1c */
2017         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2018         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2019         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2020         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2021         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2022         /* Mute input pins 0x18-0x1b */
2023         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2024         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2025         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2026         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2027         /* ADC set up */
2028         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2029         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2030         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2031         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2032         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2033         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2034         /* Analog input/passthru */
2035         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2036         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2037         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2038         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2039         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2040         { }
2041 };
2042 #endif
2043
2044 /*
2045  */
2046
2047 static struct hda_board_config alc880_cfg_tbl[] = {
2048         /* Back 3 jack, front 2 jack */
2049         { .modelname = "3stack", .config = ALC880_3ST },
2050         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe200, .config = ALC880_3ST },
2051         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe201, .config = ALC880_3ST },
2052         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe202, .config = ALC880_3ST },
2053         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe203, .config = ALC880_3ST },
2054         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe204, .config = ALC880_3ST },
2055         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe205, .config = ALC880_3ST },
2056         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe206, .config = ALC880_3ST },
2057         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe207, .config = ALC880_3ST },
2058         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe208, .config = ALC880_3ST },
2059         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe209, .config = ALC880_3ST },
2060         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20a, .config = ALC880_3ST },
2061         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20b, .config = ALC880_3ST },
2062         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20c, .config = ALC880_3ST },
2063         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20d, .config = ALC880_3ST },
2064         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20e, .config = ALC880_3ST },
2065         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe20f, .config = ALC880_3ST },
2066         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe210, .config = ALC880_3ST },
2067         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe211, .config = ALC880_3ST },
2068         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe214, .config = ALC880_3ST },
2069         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe302, .config = ALC880_3ST },
2070         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe303, .config = ALC880_3ST },
2071         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe304, .config = ALC880_3ST },
2072         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe306, .config = ALC880_3ST },
2073         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe307, .config = ALC880_3ST },
2074         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe404, .config = ALC880_3ST },
2075         { .pci_subvendor = 0x8086, .pci_subdevice = 0xa101, .config = ALC880_3ST },
2076         { .pci_subvendor = 0x107b, .pci_subdevice = 0x3031, .config = ALC880_3ST },
2077         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4036, .config = ALC880_3ST },
2078         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4037, .config = ALC880_3ST },
2079         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4038, .config = ALC880_3ST },
2080         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4040, .config = ALC880_3ST },
2081         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4041, .config = ALC880_3ST },
2082         /* TCL S700 */
2083         { .pci_subvendor = 0x19db, .pci_subdevice = 0x4188, .config = ALC880_TCL_S700 },
2084
2085         /* Back 3 jack, front 2 jack (Internal add Aux-In) */
2086         { .pci_subvendor = 0x1025, .pci_subdevice = 0xe310, .config = ALC880_3ST },
2087         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81d6, .config = ALC880_3ST }, 
2088         { .pci_subvendor = 0x104d, .pci_subdevice = 0x81a0, .config = ALC880_3ST },
2089
2090         /* Back 3 jack plus 1 SPDIF out jack, front 2 jack */
2091         { .modelname = "3stack-digout", .config = ALC880_3ST_DIG },
2092         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe308, .config = ALC880_3ST_DIG },
2093         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0070, .config = ALC880_3ST_DIG },
2094         /* Clevo m520G NB */
2095         { .pci_subvendor = 0x1558, .pci_subdevice = 0x0520, .config = ALC880_CLEVO },
2096
2097         /* Back 3 jack plus 1 SPDIF out jack, front 2 jack (Internal add Aux-In)*/
2098         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe305, .config = ALC880_3ST_DIG },
2099         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd402, .config = ALC880_3ST_DIG },
2100         { .pci_subvendor = 0x1025, .pci_subdevice = 0xe309, .config = ALC880_3ST_DIG },
2101
2102         /* Back 5 jack, front 2 jack */
2103         { .modelname = "5stack", .config = ALC880_5ST },
2104         { .pci_subvendor = 0x107b, .pci_subdevice = 0x3033, .config = ALC880_5ST },
2105         { .pci_subvendor = 0x107b, .pci_subdevice = 0x4039, .config = ALC880_5ST },
2106         { .pci_subvendor = 0x107b, .pci_subdevice = 0x3032, .config = ALC880_5ST },
2107         { .pci_subvendor = 0x103c, .pci_subdevice = 0x2a09, .config = ALC880_5ST },
2108         { .pci_subvendor = 0x1043, .pci_subdevice = 0x814e, .config = ALC880_5ST },
2109
2110         /* Back 5 jack plus 1 SPDIF out jack, front 2 jack */
2111         { .modelname = "5stack-digout", .config = ALC880_5ST_DIG },
2112         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe224, .config = ALC880_5ST_DIG },
2113         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe400, .config = ALC880_5ST_DIG },
2114         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe401, .config = ALC880_5ST_DIG },
2115         { .pci_subvendor = 0x8086, .pci_subdevice = 0xe402, .config = ALC880_5ST_DIG },
2116         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd400, .config = ALC880_5ST_DIG },
2117         { .pci_subvendor = 0x8086, .pci_subdevice = 0xd401, .config = ALC880_5ST_DIG },
2118         { .pci_subvendor = 0x8086, .pci_subdevice = 0xa100, .config = ALC880_5ST_DIG },
2119         { .pci_subvendor = 0x1565, .pci_subdevice = 0x8202, .config = ALC880_5ST_DIG },
2120         { .pci_subvendor = 0x1019, .pci_subdevice = 0xa880, .config = ALC880_5ST_DIG },
2121         { .pci_subvendor = 0xa0a0, .pci_subdevice = 0x0560,
2122           .config = ALC880_5ST_DIG }, /* Aopen i915GMm-HFS */
2123         /* { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_5ST_DIG }, */ /* conflict with 6stack */
2124         { .pci_subvendor = 0x1695, .pci_subdevice = 0x400d, .config = ALC880_5ST_DIG },
2125         /* note subvendor = 0 below */
2126         /* { .pci_subvendor = 0x0000, .pci_subdevice = 0x8086, .config = ALC880_5ST_DIG }, */
2127
2128         { .modelname = "w810", .config = ALC880_W810 },
2129         { .pci_subvendor = 0x161f, .pci_subdevice = 0x203d, .config = ALC880_W810 },
2130
2131         { .modelname = "z71v", .config = ALC880_Z71V },
2132         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_Z71V },
2133
2134         { .modelname = "6stack", .config = ALC880_6ST },
2135         { .pci_subvendor = 0x1043, .pci_subdevice = 0x8196, .config = ALC880_6ST }, /* ASUS P5GD1-HVM */
2136         { .pci_subvendor = 0x1043, .pci_subdevice = 0x81b4, .config = ALC880_6ST },
2137         { .pci_subvendor = 0x1019, .pci_subdevice = 0xa884, .config = ALC880_6ST }, /* Acer APFV */
2138         { .pci_subvendor = 0x1458, .pci_subdevice = 0xa102, .config = ALC880_6ST }, /* Gigabyte K8N51 */
2139
2140         { .modelname = "6stack-digout", .config = ALC880_6ST_DIG },
2141         { .pci_subvendor = 0x2668, .pci_subdevice = 0x8086, .config = ALC880_6ST_DIG },
2142         { .pci_subvendor = 0x8086, .pci_subdevice = 0x2668, .config = ALC880_6ST_DIG },
2143         { .pci_subvendor = 0x1462, .pci_subdevice = 0x1150, .config = ALC880_6ST_DIG },
2144         { .pci_subvendor = 0xe803, .pci_subdevice = 0x1019, .config = ALC880_6ST_DIG },
2145         { .pci_subvendor = 0x1039, .pci_subdevice = 0x1234, .config = ALC880_6ST_DIG },
2146         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0077, .config = ALC880_6ST_DIG },
2147         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0078, .config = ALC880_6ST_DIG },
2148         { .pci_subvendor = 0x1025, .pci_subdevice = 0x0087, .config = ALC880_6ST_DIG },
2149         { .pci_subvendor = 0x1297, .pci_subdevice = 0xc790, .config = ALC880_6ST_DIG }, /* Shuttle ST20G5 */
2150         { .pci_subvendor = 0x1509, .pci_subdevice = 0x925d, .config = ALC880_6ST_DIG }, /* FIC P4M-915GD1 */
2151         { .pci_subvendor = 0x1695, .pci_subdevice = 0x4012, .config = ALC880_5ST_DIG }, /* Epox EP-5LDA+ GLi */
2152
2153         { .modelname = "asus", .config = ALC880_ASUS },
2154         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1964, .config = ALC880_ASUS_DIG },
2155         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1973, .config = ALC880_ASUS_DIG },
2156         { .pci_subvendor = 0x1043, .pci_subdevice = 0x19b3, .config = ALC880_ASUS_DIG },
2157         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1113, .config = ALC880_ASUS_DIG },
2158         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1173, .config = ALC880_ASUS_DIG },
2159         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1993, .config = ALC880_ASUS },
2160         { .pci_subvendor = 0x1043, .pci_subdevice = 0x10c3, .config = ALC880_ASUS_DIG },
2161         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1133, .config = ALC880_ASUS },
2162         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1123, .config = ALC880_ASUS_DIG },
2163         { .pci_subvendor = 0x1043, .pci_subdevice = 0x1143, .config = ALC880_ASUS },
2164         { .pci_subvendor = 0x1043, .pci_subdevice = 0x10b3, .config = ALC880_ASUS_W1V },
2165         { .pci_subvendor = 0x1043, .pci_subdevice = 0x8181, .config = ALC880_ASUS_DIG }, /* ASUS P4GPL-X */
2166         { .pci_subvendor = 0x1558, .pci_subdevice = 0x5401, .config = ALC880_ASUS_DIG2 },
2167
2168         { .modelname = "uniwill", .config = ALC880_UNIWILL_DIG },
2169         { .pci_subvendor = 0x1584, .pci_subdevice = 0x9050, .config = ALC880_UNIWILL_DIG },     
2170
2171         { .modelname = "F1734", .config = ALC880_F1734 },
2172         { .pci_subvendor = 0x1734, .pci_subdevice = 0x107c, .config = ALC880_F1734 },
2173         { .pci_subvendor = 0x1584, .pci_subdevice = 0x9054, .config = ALC880_F1734 },
2174
2175         { .modelname = "lg", .config = ALC880_LG },
2176         { .pci_subvendor = 0x1854, .pci_subdevice = 0x003b, .config = ALC880_LG },
2177         { .pci_subvendor = 0x1854, .pci_subdevice = 0x0068, .config = ALC880_LG },
2178
2179         { .modelname = "lg-lw", .config = ALC880_LG_LW },
2180         { .pci_subvendor = 0x1854, .pci_subdevice = 0x0018, .config = ALC880_LG_LW },
2181
2182 #ifdef CONFIG_SND_DEBUG
2183         { .modelname = "test", .config = ALC880_TEST },
2184 #endif
2185         { .modelname = "auto", .config = ALC880_AUTO },
2186
2187         {}
2188 };
2189
2190 /*
2191  * ALC880 codec presets
2192  */
2193 static struct alc_config_preset alc880_presets[] = {
2194         [ALC880_3ST] = {
2195                 .mixers = { alc880_three_stack_mixer },
2196                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
2197                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2198                 .dac_nids = alc880_dac_nids,
2199                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2200                 .channel_mode = alc880_threestack_modes,
2201                 .input_mux = &alc880_capture_source,
2202         },
2203         [ALC880_3ST_DIG] = {
2204                 .mixers = { alc880_three_stack_mixer },
2205                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_3stack_init_verbs },
2206                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2207                 .dac_nids = alc880_dac_nids,
2208                 .dig_out_nid = ALC880_DIGOUT_NID,
2209                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2210                 .channel_mode = alc880_threestack_modes,
2211                 .input_mux = &alc880_capture_source,
2212         },
2213         [ALC880_TCL_S700] = {
2214                 .mixers = { alc880_tcl_s700_mixer },
2215                 .init_verbs = { alc880_volume_init_verbs,
2216                                 alc880_pin_tcl_S700_init_verbs,
2217                                 alc880_gpio2_init_verbs },
2218                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2219                 .dac_nids = alc880_dac_nids,
2220                 .hp_nid = 0x03,
2221                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2222                 .channel_mode = alc880_2_jack_modes,
2223                 .input_mux = &alc880_capture_source,
2224         },
2225         [ALC880_5ST] = {
2226                 .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer},
2227                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
2228                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2229                 .dac_nids = alc880_dac_nids,
2230                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
2231                 .channel_mode = alc880_fivestack_modes,
2232                 .input_mux = &alc880_capture_source,
2233         },
2234         [ALC880_5ST_DIG] = {
2235                 .mixers = { alc880_three_stack_mixer, alc880_five_stack_mixer },
2236                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_5stack_init_verbs },
2237                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2238                 .dac_nids = alc880_dac_nids,
2239                 .dig_out_nid = ALC880_DIGOUT_NID,
2240                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
2241                 .channel_mode = alc880_fivestack_modes,
2242                 .input_mux = &alc880_capture_source,
2243         },
2244         [ALC880_6ST] = {
2245                 .mixers = { alc880_six_stack_mixer },
2246                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
2247                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
2248                 .dac_nids = alc880_6st_dac_nids,
2249                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
2250                 .channel_mode = alc880_sixstack_modes,
2251                 .input_mux = &alc880_6stack_capture_source,
2252         },
2253         [ALC880_6ST_DIG] = {
2254                 .mixers = { alc880_six_stack_mixer },
2255                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_6stack_init_verbs },
2256                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
2257                 .dac_nids = alc880_6st_dac_nids,
2258                 .dig_out_nid = ALC880_DIGOUT_NID,
2259                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
2260                 .channel_mode = alc880_sixstack_modes,
2261                 .input_mux = &alc880_6stack_capture_source,
2262         },
2263         [ALC880_W810] = {
2264                 .mixers = { alc880_w810_base_mixer },
2265                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_w810_init_verbs,
2266                                 alc880_gpio2_init_verbs },
2267                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
2268                 .dac_nids = alc880_w810_dac_nids,
2269                 .dig_out_nid = ALC880_DIGOUT_NID,
2270                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
2271                 .channel_mode = alc880_w810_modes,
2272                 .input_mux = &alc880_capture_source,
2273         },
2274         [ALC880_Z71V] = {
2275                 .mixers = { alc880_z71v_mixer },
2276                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_z71v_init_verbs },
2277                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
2278                 .dac_nids = alc880_z71v_dac_nids,
2279                 .dig_out_nid = ALC880_DIGOUT_NID,
2280                 .hp_nid = 0x03,
2281                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2282                 .channel_mode = alc880_2_jack_modes,
2283                 .input_mux = &alc880_capture_source,
2284         },
2285         [ALC880_F1734] = {
2286                 .mixers = { alc880_f1734_mixer },
2287                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_f1734_init_verbs },
2288                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
2289                 .dac_nids = alc880_f1734_dac_nids,
2290                 .hp_nid = 0x02,
2291                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2292                 .channel_mode = alc880_2_jack_modes,
2293                 .input_mux = &alc880_capture_source,
2294         },
2295         [ALC880_ASUS] = {
2296                 .mixers = { alc880_asus_mixer },
2297                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2298                                 alc880_gpio1_init_verbs },
2299                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2300                 .dac_nids = alc880_asus_dac_nids,
2301                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2302                 .channel_mode = alc880_asus_modes,
2303                 .input_mux = &alc880_capture_source,
2304         },
2305         [ALC880_ASUS_DIG] = {
2306                 .mixers = { alc880_asus_mixer },
2307                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2308                                 alc880_gpio1_init_verbs },
2309                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2310                 .dac_nids = alc880_asus_dac_nids,
2311                 .dig_out_nid = ALC880_DIGOUT_NID,
2312                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2313                 .channel_mode = alc880_asus_modes,
2314                 .input_mux = &alc880_capture_source,
2315         },
2316         [ALC880_ASUS_DIG2] = {
2317                 .mixers = { alc880_asus_mixer },
2318                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2319                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
2320                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2321                 .dac_nids = alc880_asus_dac_nids,
2322                 .dig_out_nid = ALC880_DIGOUT_NID,
2323                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2324                 .channel_mode = alc880_asus_modes,
2325                 .input_mux = &alc880_capture_source,
2326         },
2327         [ALC880_ASUS_W1V] = {
2328                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
2329                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs,
2330                                 alc880_gpio1_init_verbs },
2331                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2332                 .dac_nids = alc880_asus_dac_nids,
2333                 .dig_out_nid = ALC880_DIGOUT_NID,
2334                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2335                 .channel_mode = alc880_asus_modes,
2336                 .input_mux = &alc880_capture_source,
2337         },
2338         [ALC880_UNIWILL_DIG] = {
2339                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
2340                 .init_verbs = { alc880_volume_init_verbs, alc880_pin_asus_init_verbs },
2341                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
2342                 .dac_nids = alc880_asus_dac_nids,
2343                 .dig_out_nid = ALC880_DIGOUT_NID,
2344                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
2345                 .channel_mode = alc880_asus_modes,
2346                 .input_mux = &alc880_capture_source,
2347         },
2348         [ALC880_CLEVO] = {
2349                 .mixers = { alc880_three_stack_mixer },
2350                 .init_verbs = { alc880_volume_init_verbs,
2351                                 alc880_pin_clevo_init_verbs },
2352                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
2353                 .dac_nids = alc880_dac_nids,
2354                 .hp_nid = 0x03,
2355                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
2356                 .channel_mode = alc880_threestack_modes,
2357                 .input_mux = &alc880_capture_source,
2358         },
2359         [ALC880_LG] = {
2360                 .mixers = { alc880_lg_mixer },
2361                 .init_verbs = { alc880_volume_init_verbs,
2362                                 alc880_lg_init_verbs },
2363                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
2364                 .dac_nids = alc880_lg_dac_nids,
2365                 .dig_out_nid = ALC880_DIGOUT_NID,
2366                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
2367                 .channel_mode = alc880_lg_ch_modes,
2368                 .input_mux = &alc880_lg_capture_source,
2369                 .unsol_event = alc880_lg_unsol_event,
2370                 .init_hook = alc880_lg_automute,
2371         },
2372         [ALC880_LG_LW] = {
2373                 .mixers = { alc880_lg_lw_mixer },
2374                 .init_verbs = { alc880_volume_init_verbs,
2375                                 alc880_lg_lw_init_verbs },
2376                 .num_dacs = 1, 
2377                 .dac_nids = alc880_dac_nids,
2378                 .dig_out_nid = ALC880_DIGOUT_NID,
2379                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
2380                 .channel_mode = alc880_2_jack_modes,
2381                 .input_mux = &alc880_lg_lw_capture_source,
2382                 .unsol_event = alc880_lg_lw_unsol_event,
2383                 .init_hook = alc880_lg_lw_automute,
2384         },
2385 #ifdef CONFIG_SND_DEBUG
2386         [ALC880_TEST] = {
2387                 .mixers = { alc880_test_mixer },
2388                 .init_verbs = { alc880_test_init_verbs },
2389                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
2390                 .dac_nids = alc880_test_dac_nids,
2391                 .dig_out_nid = ALC880_DIGOUT_NID,
2392                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
2393                 .channel_mode = alc880_test_modes,
2394                 .input_mux = &alc880_test_capture_source,
2395         },
2396 #endif
2397 };
2398
2399 /*
2400  * Automatic parse of I/O pins from the BIOS configuration
2401  */
2402
2403 #define NUM_CONTROL_ALLOC       32
2404 #define NUM_VERB_ALLOC          32
2405
2406 enum {
2407         ALC_CTL_WIDGET_VOL,
2408         ALC_CTL_WIDGET_MUTE,
2409         ALC_CTL_BIND_MUTE,
2410 };
2411 static struct snd_kcontrol_new alc880_control_templates[] = {
2412         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2413         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2414         HDA_BIND_MUTE(NULL, 0, 0, 0),
2415 };
2416
2417 /* add dynamic controls */
2418 static int add_control(struct alc_spec *spec, int type, const char *name, unsigned long val)
2419 {
2420         struct snd_kcontrol_new *knew;
2421
2422         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
2423                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
2424
2425                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */
2426                 if (! knew)
2427                         return -ENOMEM;
2428                 if (spec->kctl_alloc) {
2429                         memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc);
2430                         kfree(spec->kctl_alloc);
2431                 }
2432                 spec->kctl_alloc = knew;
2433                 spec->num_kctl_alloc = num;
2434         }
2435
2436         knew = &spec->kctl_alloc[spec->num_kctl_used];
2437         *knew = alc880_control_templates[type];
2438         knew->name = kstrdup(name, GFP_KERNEL);
2439         if (! knew->name)
2440                 return -ENOMEM;
2441         knew->private_value = val;
2442         spec->num_kctl_used++;
2443         return 0;
2444 }
2445
2446 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
2447 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
2448 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
2449 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
2450 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
2451 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
2452 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
2453 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
2454 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
2455 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
2456 #define ALC880_PIN_CD_NID               0x1c
2457
2458 /* fill in the dac_nids table from the parsed pin configuration */
2459 static int alc880_auto_fill_dac_nids(struct alc_spec *spec, const struct auto_pin_cfg *cfg)
2460 {
2461         hda_nid_t nid;
2462         int assigned[4];
2463         int i, j;
2464
2465         memset(assigned, 0, sizeof(assigned));
2466         spec->multiout.dac_nids = spec->private_dac_nids;
2467
2468         /* check the pins hardwired to audio widget */
2469         for (i = 0; i < cfg->line_outs; i++) {
2470                 nid = cfg->line_out_pins[i];
2471                 if (alc880_is_fixed_pin(nid)) {
2472                         int idx = alc880_fixed_pin_idx(nid);
2473                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
2474                         assigned[idx] = 1;
2475                 }
2476         }
2477         /* left pins can be connect to any audio widget */
2478         for (i = 0; i < cfg->line_outs; i++) {
2479                 nid = cfg->line_out_pins[i];
2480                 if (alc880_is_fixed_pin(nid))
2481                         continue;
2482                 /* search for an empty channel */
2483                 for (j = 0; j < cfg->line_outs; j++) {
2484                         if (! assigned[j]) {
2485                                 spec->multiout.dac_nids[i] = alc880_idx_to_dac(j);
2486                                 assigned[j] = 1;
2487                                 break;
2488                         }
2489                 }
2490         }
2491         spec->multiout.num_dacs = cfg->line_outs;
2492         return 0;
2493 }
2494
2495 /* add playback controls from the parsed DAC table */
2496 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
2497                                              const struct auto_pin_cfg *cfg)
2498 {
2499         char name[32];
2500         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2501         hda_nid_t nid;
2502         int i, err;
2503
2504         for (i = 0; i < cfg->line_outs; i++) {
2505                 if (! spec->multiout.dac_nids[i])
2506                         continue;
2507                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
2508                 if (i == 2) {
2509                         /* Center/LFE */
2510                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "Center Playback Volume",
2511                                                HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT))) < 0)
2512                                 return err;
2513                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, "LFE Playback Volume",
2514                                                HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT))) < 0)
2515                                 return err;
2516                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "Center Playback Switch",
2517                                                HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT))) < 0)
2518                                 return err;
2519                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, "LFE Playback Switch",
2520                                                HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT))) < 0)
2521                                 return err;
2522                 } else {
2523                         sprintf(name, "%s Playback Volume", chname[i]);
2524                         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2525                                                HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2526                                 return err;
2527                         sprintf(name, "%s Playback Switch", chname[i]);
2528                         if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
2529                                                HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2530                                 return err;
2531                 }
2532         }
2533         return 0;
2534 }
2535
2536 /* add playback controls for speaker and HP outputs */
2537 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
2538                                         const char *pfx)
2539 {
2540         hda_nid_t nid;
2541         int err;
2542         char name[32];
2543
2544         if (! pin)
2545                 return 0;
2546
2547         if (alc880_is_fixed_pin(pin)) {
2548                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
2549                 /* specify the DAC as the extra output */
2550                 if (! spec->multiout.hp_nid)
2551                         spec->multiout.hp_nid = nid;
2552                 else
2553                         spec->multiout.extra_out_nid[0] = nid;
2554                 /* control HP volume/switch on the output mixer amp */
2555                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
2556                 sprintf(name, "%s Playback Volume", pfx);
2557                 if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2558                                        HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT))) < 0)
2559                         return err;
2560                 sprintf(name, "%s Playback Switch", pfx);
2561                 if ((err = add_control(spec, ALC_CTL_BIND_MUTE, name,
2562                                        HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2563                         return err;
2564         } else if (alc880_is_multi_pin(pin)) {
2565                 /* set manual connection */
2566                 /* we have only a switch on HP-out PIN */
2567                 sprintf(name, "%s Playback Switch", pfx);
2568                 if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
2569                                        HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT))) < 0)
2570                         return err;
2571         }
2572         return 0;
2573 }
2574
2575 /* create input playback/capture controls for the given pin */
2576 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, const char *ctlname,
2577                             int idx, hda_nid_t mix_nid)
2578 {
2579         char name[32];
2580         int err;
2581
2582         sprintf(name, "%s Playback Volume", ctlname);
2583         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
2584                                HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
2585                 return err;
2586         sprintf(name, "%s Playback Switch", ctlname);
2587         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
2588                                HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT))) < 0)
2589                 return err;
2590         return 0;
2591 }
2592
2593 /* create playback/capture controls for input pins */
2594 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
2595                                                 const struct auto_pin_cfg *cfg)
2596 {
2597         struct hda_input_mux *imux = &spec->private_imux;
2598         int i, err, idx;
2599
2600         for (i = 0; i < AUTO_PIN_LAST; i++) {
2601                 if (alc880_is_input_pin(cfg->input_pins[i])) {
2602                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
2603                         err = new_analog_input(spec, cfg->input_pins[i],
2604                                                auto_pin_cfg_labels[i],
2605                                                idx, 0x0b);
2606                         if (err < 0)
2607                                 return err;
2608                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2609                         imux->items[imux->num_items].index = alc880_input_pin_idx(cfg->input_pins[i]);
2610                         imux->num_items++;
2611                 }
2612         }
2613         return 0;
2614 }
2615
2616 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
2617                                               hda_nid_t nid, int pin_type,
2618                                               int dac_idx)
2619 {
2620         /* set as output */
2621         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2622         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2623         /* need the manual connection? */
2624         if (alc880_is_multi_pin(nid)) {
2625                 struct alc_spec *spec = codec->spec;
2626                 int idx = alc880_multi_pin_idx(nid);
2627                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
2628                                     AC_VERB_SET_CONNECT_SEL,
2629                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
2630         }
2631 }
2632
2633 static void alc880_auto_init_multi_out(struct hda_codec *codec)
2634 {
2635         struct alc_spec *spec = codec->spec;
2636         int i;
2637
2638         for (i = 0; i < spec->autocfg.line_outs; i++) {
2639                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2640                 alc880_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2641         }
2642 }
2643
2644 static void alc880_auto_init_extra_out(struct hda_codec *codec)
2645 {
2646         struct alc_spec *spec = codec->spec;
2647         hda_nid_t pin;
2648
2649         pin = spec->autocfg.speaker_pins[0];
2650         if (pin) /* connect to front */
2651                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2652         pin = spec->autocfg.hp_pin;
2653         if (pin) /* connect to front */
2654                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2655 }
2656
2657 static void alc880_auto_init_analog_input(struct hda_codec *codec)
2658 {
2659         struct alc_spec *spec = codec->spec;
2660         int i;
2661
2662         for (i = 0; i < AUTO_PIN_LAST; i++) {
2663                 hda_nid_t nid = spec->autocfg.input_pins[i];
2664                 if (alc880_is_input_pin(nid)) {
2665                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2666                                             i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2667                         if (nid != ALC880_PIN_CD_NID)
2668                                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2669                                                     AMP_OUT_MUTE);
2670                 }
2671         }
2672 }
2673
2674 /* parse the BIOS configuration and set up the alc_spec */
2675 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2676 static int alc880_parse_auto_config(struct hda_codec *codec)
2677 {
2678         struct alc_spec *spec = codec->spec;
2679         int err;
2680         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
2681
2682         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
2683                                                 alc880_ignore)) < 0)
2684                 return err;
2685         if (! spec->autocfg.line_outs)
2686                 return 0; /* can't find valid BIOS pin config */
2687
2688         if ((err = alc880_auto_fill_dac_nids(spec, &spec->autocfg)) < 0 ||
2689             (err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2690             (err = alc880_auto_create_extra_out(spec,
2691                                                 spec->autocfg.speaker_pins[0],
2692                                                 "Speaker")) < 0 ||
2693             (err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pin,
2694                                                 "Headphone")) < 0 ||
2695             (err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2696                 return err;
2697
2698         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2699
2700         if (spec->autocfg.dig_out_pin)
2701                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
2702         if (spec->autocfg.dig_in_pin)
2703                 spec->dig_in_nid = ALC880_DIGIN_NID;
2704
2705         if (spec->kctl_alloc)
2706                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2707
2708         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
2709
2710         spec->num_mux_defs = 1;
2711         spec->input_mux = &spec->private_imux;
2712
2713         return 1;
2714 }
2715
2716 /* additional initialization for auto-configuration model */
2717 static void alc880_auto_init(struct hda_codec *codec)
2718 {
2719         alc880_auto_init_multi_out(codec);
2720         alc880_auto_init_extra_out(codec);
2721         alc880_auto_init_analog_input(codec);
2722 }
2723
2724 /*
2725  * OK, here we have finally the patch for ALC880
2726  */
2727
2728 static int patch_alc880(struct hda_codec *codec)
2729 {
2730         struct alc_spec *spec;
2731         int board_config;
2732         int err;
2733
2734         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2735         if (spec == NULL)
2736                 return -ENOMEM;
2737
2738         codec->spec = spec;
2739
2740         board_config = snd_hda_check_board_config(codec, alc880_cfg_tbl);
2741         if (board_config < 0 || board_config >= ALC880_MODEL_LAST) {
2742                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, trying auto-probe from BIOS...\n");
2743                 board_config = ALC880_AUTO;
2744         }
2745
2746         if (board_config == ALC880_AUTO) {
2747                 /* automatic parse from the BIOS config */
2748                 err = alc880_parse_auto_config(codec);
2749                 if (err < 0) {
2750                         alc_free(codec);
2751                         return err;
2752                 } else if (! err) {
2753                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 3-stack mode...\n");
2754                         board_config = ALC880_3ST;
2755                 }
2756         }
2757
2758         if (board_config != ALC880_AUTO)
2759                 setup_preset(spec, &alc880_presets[board_config]);
2760
2761         spec->stream_name_analog = "ALC880 Analog";
2762         spec->stream_analog_playback = &alc880_pcm_analog_playback;
2763         spec->stream_analog_capture = &alc880_pcm_analog_capture;
2764
2765         spec->stream_name_digital = "ALC880 Digital";
2766         spec->stream_digital_playback = &alc880_pcm_digital_playback;
2767         spec->stream_digital_capture = &alc880_pcm_digital_capture;
2768
2769         if (! spec->adc_nids && spec->input_mux) {
2770                 /* check whether NID 0x07 is valid */
2771                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
2772                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
2773                 if (wcap != AC_WID_AUD_IN) {
2774                         spec->adc_nids = alc880_adc_nids_alt;
2775                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
2776                         spec->mixers[spec->num_mixers] = alc880_capture_alt_mixer;
2777                         spec->num_mixers++;
2778                 } else {
2779                         spec->adc_nids = alc880_adc_nids;
2780                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
2781                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
2782                         spec->num_mixers++;
2783                 }
2784         }
2785
2786         codec->patch_ops = alc_patch_ops;
2787         if (board_config == ALC880_AUTO)
2788                 spec->init_hook = alc880_auto_init;
2789
2790         return 0;
2791 }
2792
2793
2794 /*
2795  * ALC260 support
2796  */
2797
2798 static hda_nid_t alc260_dac_nids[1] = {
2799         /* front */
2800         0x02,
2801 };
2802
2803 static hda_nid_t alc260_adc_nids[1] = {
2804         /* ADC0 */
2805         0x04,
2806 };
2807
2808 static hda_nid_t alc260_adc_nids_alt[1] = {
2809         /* ADC1 */
2810         0x05,
2811 };
2812
2813 static hda_nid_t alc260_hp_adc_nids[2] = {
2814         /* ADC1, 0 */
2815         0x05, 0x04
2816 };
2817
2818 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
2819  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
2820  */
2821 static hda_nid_t alc260_dual_adc_nids[2] = {
2822         /* ADC0, ADC1 */
2823         0x04, 0x05
2824 };
2825
2826 #define ALC260_DIGOUT_NID       0x03
2827 #define ALC260_DIGIN_NID        0x06
2828
2829 static struct hda_input_mux alc260_capture_source = {
2830         .num_items = 4,
2831         .items = {
2832                 { "Mic", 0x0 },
2833                 { "Front Mic", 0x1 },
2834                 { "Line", 0x2 },
2835                 { "CD", 0x4 },
2836         },
2837 };
2838
2839 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
2840  * headphone jack and the internal CD lines since these are the only pins at
2841  * which audio can appear.  For flexibility, also allow the option of
2842  * recording the mixer output on the second ADC (ADC0 doesn't have a
2843  * connection to the mixer output).
2844  */
2845 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
2846         {
2847                 .num_items = 3,
2848                 .items = {
2849                         { "Mic/Line", 0x0 },
2850                         { "CD", 0x4 },
2851                         { "Headphone", 0x2 },
2852                 },
2853         },
2854         {
2855                 .num_items = 4,
2856                 .items = {
2857                         { "Mic/Line", 0x0 },
2858                         { "CD", 0x4 },
2859                         { "Headphone", 0x2 },
2860                         { "Mixer", 0x5 },
2861                 },
2862         },
2863
2864 };
2865
2866 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
2867  * the Fujitsu S702x, but jacks are marked differently.
2868  */
2869 static struct hda_input_mux alc260_acer_capture_sources[2] = {
2870         {
2871                 .num_items = 4,
2872                 .items = {
2873                         { "Mic", 0x0 },
2874                         { "Line", 0x2 },
2875                         { "CD", 0x4 },
2876                         { "Headphone", 0x5 },
2877                 },
2878         },
2879         {
2880                 .num_items = 5,
2881                 .items = {
2882                         { "Mic", 0x0 },
2883                         { "Line", 0x2 },
2884                         { "CD", 0x4 },
2885                         { "Headphone", 0x6 },
2886                         { "Mixer", 0x5 },
2887                 },
2888         },
2889 };
2890 /*
2891  * This is just place-holder, so there's something for alc_build_pcms to look
2892  * at when it calculates the maximum number of channels. ALC260 has no mixer
2893  * element which allows changing the channel mode, so the verb list is
2894  * never used.
2895  */
2896 static struct hda_channel_mode alc260_modes[1] = {
2897         { 2, NULL },
2898 };
2899
2900
2901 /* Mixer combinations
2902  *
2903  * basic: base_output + input + pc_beep + capture
2904  * HP: base_output + input + capture_alt
2905  * HP_3013: hp_3013 + input + capture
2906  * fujitsu: fujitsu + capture
2907  * acer: acer + capture
2908  */
2909
2910 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
2911         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2912         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
2913         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
2914         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
2915         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2916         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
2917         { } /* end */
2918 };      
2919
2920 static struct snd_kcontrol_new alc260_input_mixer[] = {
2921         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
2922         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
2923         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
2924         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
2925         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
2926         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
2927         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
2928         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
2929         { } /* end */
2930 };
2931
2932 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
2933         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
2934         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
2935         { } /* end */
2936 };
2937
2938 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
2939         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
2940         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2941         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
2942         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
2943         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
2945         HDA_CODEC_VOLUME_MONO("iSpeaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
2946         HDA_CODEC_MUTE_MONO("iSpeaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
2947         { } /* end */
2948 };
2949
2950 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12, 
2951  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
2952  */
2953 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
2954         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2955         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
2956         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
2957         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
2958         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
2959         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
2960         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
2961         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
2962         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
2963         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
2964         HDA_CODEC_VOLUME("Internal Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
2965         HDA_BIND_MUTE("Internal Speaker Playback Switch", 0x09, 2, HDA_INPUT),
2966         { } /* end */
2967 };
2968
2969 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
2970  * versions of the ALC260 don't act on requests to enable mic bias from NID
2971  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
2972  * datasheet doesn't mention this restriction.  At this stage it's not clear
2973  * whether this behaviour is intentional or is a hardware bug in chip
2974  * revisions available in early 2006.  Therefore for now allow the
2975  * "Headphone Jack Mode" control to span all choices, but if it turns out
2976  * that the lack of mic bias for this NID is intentional we could change the
2977  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
2978  *
2979  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
2980  * don't appear to make the mic bias available from the "line" jack, even
2981  * though the NID used for this jack (0x14) can supply it.  The theory is
2982  * that perhaps Acer have included blocking capacitors between the ALC260
2983  * and the output jack.  If this turns out to be the case for all such
2984  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
2985  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
2986  */
2987 static struct snd_kcontrol_new alc260_acer_mixer[] = {
2988         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
2989         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
2990         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
2991         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
2992         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
2993         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
2994         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
2995         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
2996         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
2997         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
2998         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
2999         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3000         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3001         { } /* end */
3002 };
3003
3004 /* capture mixer elements */
3005 static struct snd_kcontrol_new alc260_capture_mixer[] = {
3006         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
3007         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
3008         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
3009         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
3010         {
3011                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3012                 /* The multiple "Capture Source" controls confuse alsamixer
3013                  * So call somewhat different..
3014                  * FIXME: the controls appear in the "playback" view!
3015                  */
3016                 /* .name = "Capture Source", */
3017                 .name = "Input Source",
3018                 .count = 2,
3019                 .info = alc_mux_enum_info,
3020                 .get = alc_mux_enum_get,
3021                 .put = alc_mux_enum_put,
3022         },
3023         { } /* end */
3024 };
3025
3026 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
3027         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
3028         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
3029         {
3030                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3031                 /* The multiple "Capture Source" controls confuse alsamixer
3032                  * So call somewhat different..
3033                  * FIXME: the controls appear in the "playback" view!
3034                  */
3035                 /* .name = "Capture Source", */
3036                 .name = "Input Source",
3037                 .count = 1,
3038                 .info = alc_mux_enum_info,
3039                 .get = alc_mux_enum_get,
3040                 .put = alc_mux_enum_put,
3041         },
3042         { } /* end */
3043 };
3044
3045 /*
3046  * initialization verbs
3047  */
3048 static struct hda_verb alc260_init_verbs[] = {
3049         /* Line In pin widget for input */
3050         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3051         /* CD pin widget for input */
3052         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3053         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3054         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3055         /* Mic2 (front panel) pin widget for input and vref at 80% */
3056         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3057         /* LINE-2 is used for line-out in rear */
3058         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3059         /* select line-out */
3060         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
3061         /* LINE-OUT pin */
3062         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3063         /* enable HP */
3064         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3065         /* enable Mono */
3066         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3067         /* mute capture amp left and right */
3068         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3069         /* set connection select to line in (default select for this ADC) */
3070         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3071         /* mute capture amp left and right */
3072         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3073         /* set connection select to line in (default select for this ADC) */
3074         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
3075         /* set vol=0 Line-Out mixer amp left and right */
3076         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3077         /* unmute pin widget amp left and right (no gain on this amp) */
3078         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3079         /* set vol=0 HP mixer amp left and right */
3080         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3081         /* unmute pin widget amp left and right (no gain on this amp) */
3082         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3083         /* set vol=0 Mono mixer amp left and right */
3084         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3085         /* unmute pin widget amp left and right (no gain on this amp) */
3086         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3087         /* unmute LINE-2 out pin */
3088         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3089         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3090         /* mute CD */
3091         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3092         /* mute Line In */
3093         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3094         /* mute Mic */
3095         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3096         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3097         /* mute Front out path */
3098         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3099         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3100         /* mute Headphone out path */
3101         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3102         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3103         /* mute Mono out path */
3104         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3105         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3106         { }
3107 };
3108
3109 #if 0 /* should be identical with alc260_init_verbs? */
3110 static struct hda_verb alc260_hp_init_verbs[] = {
3111         /* Headphone and output */
3112         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3113         /* mono output */
3114         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3115         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3116         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3117         /* Mic2 (front panel) pin widget for input and vref at 80% */
3118         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3119         /* Line In pin widget for input */
3120         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3121         /* Line-2 pin widget for output */
3122         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3123         /* CD pin widget for input */
3124         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3125         /* unmute amp left and right */
3126         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3127         /* set connection select to line in (default select for this ADC) */
3128         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3129         /* unmute Line-Out mixer amp left and right (volume = 0) */
3130         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3131         /* mute pin widget amp left and right (no gain on this amp) */
3132         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3133         /* unmute HP mixer amp left and right (volume = 0) */
3134         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3135         /* mute pin widget amp left and right (no gain on this amp) */
3136         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3137         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3138         /* unmute CD */
3139         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3140         /* unmute Line In */
3141         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3142         /* unmute Mic */
3143         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3144         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3145         /* Unmute Front out path */
3146         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3147         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3148         /* Unmute Headphone out path */
3149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3150         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3151         /* Unmute Mono out path */
3152         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3153         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3154         { }
3155 };
3156 #endif
3157
3158 static struct hda_verb alc260_hp_3013_init_verbs[] = {
3159         /* Line out and output */
3160         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3161         /* mono output */
3162         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3163         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3164         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3165         /* Mic2 (front panel) pin widget for input and vref at 80% */
3166         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
3167         /* Line In pin widget for input */
3168         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3169         /* Headphone pin widget for output */
3170         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
3171         /* CD pin widget for input */
3172         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3173         /* unmute amp left and right */
3174         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
3175         /* set connection select to line in (default select for this ADC) */
3176         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
3177         /* unmute Line-Out mixer amp left and right (volume = 0) */
3178         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3179         /* mute pin widget amp left and right (no gain on this amp) */
3180         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3181         /* unmute HP mixer amp left and right (volume = 0) */
3182         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
3183         /* mute pin widget amp left and right (no gain on this amp) */
3184         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
3185         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 & Line In 2 = 0x03 */
3186         /* unmute CD */
3187         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
3188         /* unmute Line In */
3189         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
3190         /* unmute Mic */
3191         {0x07,  AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3192         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
3193         /* Unmute Front out path */
3194         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3195         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3196         /* Unmute Headphone out path */
3197         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3198         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3199         /* Unmute Mono out path */
3200         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3201         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3202         { }
3203 };
3204
3205 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
3206  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
3207  * audio = 0x16, internal speaker = 0x10.
3208  */
3209 static struct hda_verb alc260_fujitsu_init_verbs[] = {
3210         /* Disable all GPIOs */
3211         {0x01, AC_VERB_SET_GPIO_MASK, 0},
3212         /* Internal speaker is connected to headphone pin */
3213         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3214         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
3215         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3216         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
3217         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3218         /* Ensure all other unused pins are disabled and muted. */
3219         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3220         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3221         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3222         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3223         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3224         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3225         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3226         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3227
3228         /* Disable digital (SPDIF) pins */
3229         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3230         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3231
3232         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus 
3233          * when acting as an output.
3234          */
3235         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3236
3237         /* Start with output sum widgets muted and their output gains at min */
3238         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3239         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3240         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3241         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3242         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3243         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3244         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3245         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3246         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3247
3248         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
3249         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3250         /* Unmute Line1 pin widget output buffer since it starts as an output.
3251          * If the pin mode is changed by the user the pin mode control will
3252          * take care of enabling the pin's input/output buffers as needed.
3253          * Therefore there's no need to enable the input buffer at this
3254          * stage.
3255          */
3256         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3257         /* Unmute input buffer of pin widget used for Line-in (no equiv 
3258          * mixer ctrl)
3259          */
3260         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3261
3262         /* Mute capture amp left and right */
3263         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3264         /* Set ADC connection select to match default mixer setting - line 
3265          * in (on mic1 pin)
3266          */
3267         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3268
3269         /* Do the same for the second ADC: mute capture input amp and
3270          * set ADC connection to line in (on mic1 pin)
3271          */
3272         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3273         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3274
3275         /* Mute all inputs to mixer widget (even unconnected ones) */
3276         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3277         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3278         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3279         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3281         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3282         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3284
3285         { }
3286 };
3287
3288 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
3289  * similar laptops (adapted from Fujitsu init verbs).
3290  */
3291 static struct hda_verb alc260_acer_init_verbs[] = {
3292         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
3293          * the headphone jack.  Turn this on and rely on the standard mute
3294          * methods whenever the user wants to turn these outputs off.
3295          */
3296         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
3297         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
3298         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
3299         /* Internal speaker/Headphone jack is connected to Line-out pin */
3300         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3301         /* Internal microphone/Mic jack is connected to Mic1 pin */
3302         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3303         /* Line In jack is connected to Line1 pin */
3304         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3305         /* Ensure all other unused pins are disabled and muted. */
3306         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3307         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3308         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3309         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3310         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3311         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3312         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
3313         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3314         /* Disable digital (SPDIF) pins */
3315         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3316         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3317
3318         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum 
3319          * bus when acting as outputs.
3320          */
3321         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3322         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3323
3324         /* Start with output sum widgets muted and their output gains at min */
3325         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3326         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3327         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3328         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3329         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3330         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3331         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3332         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3333         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3334
3335         /* Unmute Line-out pin widget amp left and right (no equiv mixer ctrl) */
3336         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3337         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
3338          * inputs. If the pin mode is changed by the user the pin mode control
3339          * will take care of enabling the pin's input/output buffers as needed.
3340          * Therefore there's no need to enable the input buffer at this
3341          * stage.
3342          */
3343         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3344         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3345
3346         /* Mute capture amp left and right */
3347         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3348         /* Set ADC connection select to match default mixer setting - mic
3349          * (on mic1 pin)
3350          */
3351         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3352
3353         /* Do similar with the second ADC: mute capture input amp and
3354          * set ADC connection to mic to match ALSA's default state.
3355          */
3356         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3357         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3358
3359         /* Mute all inputs to mixer widget (even unconnected ones) */
3360         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3361         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3362         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3363         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3364         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3365         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3366         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3367         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3368
3369         { }
3370 };
3371
3372 /* Test configuration for debugging, modelled after the ALC880 test
3373  * configuration.
3374  */
3375 #ifdef CONFIG_SND_DEBUG
3376 static hda_nid_t alc260_test_dac_nids[1] = {
3377         0x02,
3378 };
3379 static hda_nid_t alc260_test_adc_nids[2] = {
3380         0x04, 0x05,
3381 };
3382 /* For testing the ALC260, each input MUX needs its own definition since
3383  * the signal assignments are different.  This assumes that the first ADC 
3384  * is NID 0x04.
3385  */
3386 static struct hda_input_mux alc260_test_capture_sources[2] = {
3387         {
3388                 .num_items = 7,
3389                 .items = {
3390                         { "MIC1 pin", 0x0 },
3391                         { "MIC2 pin", 0x1 },
3392                         { "LINE1 pin", 0x2 },
3393                         { "LINE2 pin", 0x3 },
3394                         { "CD pin", 0x4 },
3395                         { "LINE-OUT pin", 0x5 },
3396                         { "HP-OUT pin", 0x6 },
3397                 },
3398         },
3399         {
3400                 .num_items = 8,
3401                 .items = {
3402                         { "MIC1 pin", 0x0 },
3403                         { "MIC2 pin", 0x1 },
3404                         { "LINE1 pin", 0x2 },
3405                         { "LINE2 pin", 0x3 },
3406                         { "CD pin", 0x4 },
3407                         { "Mixer", 0x5 },
3408                         { "LINE-OUT pin", 0x6 },
3409                         { "HP-OUT pin", 0x7 },
3410                 },
3411         },
3412 };
3413 static struct snd_kcontrol_new alc260_test_mixer[] = {
3414         /* Output driver widgets */
3415         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
3416         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
3417         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
3418         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
3419         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
3420         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
3421
3422         /* Modes for retasking pin widgets
3423          * Note: the ALC260 doesn't seem to act on requests to enable mic
3424          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
3425          * mention this restriction.  At this stage it's not clear whether
3426          * this behaviour is intentional or is a hardware bug in chip
3427          * revisions available at least up until early 2006.  Therefore for
3428          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
3429          * choices, but if it turns out that the lack of mic bias for these
3430          * NIDs is intentional we could change their modes from
3431          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
3432          */
3433         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
3434         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
3435         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
3436         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
3437         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
3438         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
3439
3440         /* Loopback mixer controls */
3441         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
3442         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
3443         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
3444         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
3445         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
3446         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
3447         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
3448         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
3449         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
3450         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
3451         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
3452         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
3453         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
3454         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
3455         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
3456         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
3457
3458         /* Controls for GPIO pins, assuming they are configured as outputs */
3459         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
3460         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
3461         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
3462         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
3463
3464         /* Switches to allow the digital IO pins to be enabled.  The datasheet
3465          * is ambigious as to which NID is which; testing on laptops which
3466          * make this output available should provide clarification. 
3467          */
3468         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
3469         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
3470
3471         { } /* end */
3472 };
3473 static struct hda_verb alc260_test_init_verbs[] = {
3474         /* Enable all GPIOs as outputs with an initial value of 0 */
3475         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
3476         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
3477         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
3478
3479         /* Enable retasking pins as output, initially without power amp */
3480         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3481         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3482         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3483         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3484         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3485         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3486
3487         /* Disable digital (SPDIF) pins initially, but users can enable
3488          * them via a mixer switch.  In the case of SPDIF-out, this initverb
3489          * payload also sets the generation to 0, output to be in "consumer"
3490          * PCM format, copyright asserted, no pre-emphasis and no validity
3491          * control.
3492          */
3493         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
3494         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
3495
3496         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the 
3497          * OUT1 sum bus when acting as an output.
3498          */
3499         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
3500         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
3501         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
3502         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
3503
3504         /* Start with output sum widgets muted and their output gains at min */
3505         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3506         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3507         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3508         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3509         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3510         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3511         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3512         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3513         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3514
3515         /* Unmute retasking pin widget output buffers since the default
3516          * state appears to be output.  As the pin mode is changed by the
3517          * user the pin mode control will take care of enabling the pin's
3518          * input/output buffers as needed.
3519          */
3520         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3521         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3522         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3523         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3524         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3525         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3526         /* Also unmute the mono-out pin widget */
3527         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3528
3529         /* Mute capture amp left and right */
3530         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3531         /* Set ADC connection select to match default mixer setting (mic1
3532          * pin)
3533          */
3534         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
3535
3536         /* Do the same for the second ADC: mute capture input amp and
3537          * set ADC connection to mic1 pin
3538          */
3539         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3540         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
3541
3542         /* Mute all inputs to mixer widget (even unconnected ones) */
3543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
3544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
3545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
3546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
3547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
3548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
3549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
3550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
3551
3552         { }
3553 };
3554 #endif
3555
3556 static struct hda_pcm_stream alc260_pcm_analog_playback = {
3557         .substreams = 1,
3558         .channels_min = 2,
3559         .channels_max = 2,
3560 };
3561
3562 static struct hda_pcm_stream alc260_pcm_analog_capture = {
3563         .substreams = 1,
3564         .channels_min = 2,
3565         .channels_max = 2,
3566 };
3567
3568 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
3569 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
3570
3571 /*
3572  * for BIOS auto-configuration
3573  */
3574
3575 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
3576                                         const char *pfx)
3577 {
3578         hda_nid_t nid_vol;
3579         unsigned long vol_val, sw_val;
3580         char name[32];
3581         int err;
3582
3583         if (nid >= 0x0f && nid < 0x11) {
3584                 nid_vol = nid - 0x7;
3585                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
3586                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3587         } else if (nid == 0x11) {
3588                 nid_vol = nid - 0x7;
3589                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
3590                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
3591         } else if (nid >= 0x12 && nid <= 0x15) {
3592                 nid_vol = 0x08;
3593                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
3594                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3595         } else
3596                 return 0; /* N/A */
3597         
3598         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
3599         if ((err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val)) < 0)
3600                 return err;
3601         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
3602         if ((err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val)) < 0)
3603                 return err;
3604         return 1;
3605 }
3606
3607 /* add playback controls from the parsed DAC table */
3608 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
3609                                              const struct auto_pin_cfg *cfg)
3610 {
3611         hda_nid_t nid;
3612         int err;
3613
3614         spec->multiout.num_dacs = 1;
3615         spec->multiout.dac_nids = spec->private_dac_nids;
3616         spec->multiout.dac_nids[0] = 0x02;
3617
3618         nid = cfg->line_out_pins[0];
3619         if (nid) {
3620                 err = alc260_add_playback_controls(spec, nid, "Front");
3621                 if (err < 0)
3622                         return err;
3623         }
3624
3625         nid = cfg->speaker_pins[0];
3626         if (nid) {
3627                 err = alc260_add_playback_controls(spec, nid, "Speaker");
3628                 if (err < 0)
3629                         return err;
3630         }
3631
3632         nid = cfg->hp_pin;
3633         if (nid) {
3634                 err = alc260_add_playback_controls(spec, nid, "Headphone");
3635                 if (err < 0)
3636                         return err;
3637         }
3638         return 0;       
3639 }
3640
3641 /* create playback/capture controls for input pins */
3642 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
3643                                                 const struct auto_pin_cfg *cfg)
3644 {
3645         struct hda_input_mux *imux = &spec->private_imux;
3646         int i, err, idx;
3647
3648         for (i = 0; i < AUTO_PIN_LAST; i++) {
3649                 if (cfg->input_pins[i] >= 0x12) {
3650                         idx = cfg->input_pins[i] - 0x12;
3651                         err = new_analog_input(spec, cfg->input_pins[i],
3652                                                auto_pin_cfg_labels[i], idx, 0x07);
3653                         if (err < 0)
3654                                 return err;
3655                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3656                         imux->items[imux->num_items].index = idx;
3657                         imux->num_items++;
3658                 }
3659                 if ((cfg->input_pins[i] >= 0x0f) && (cfg->input_pins[i] <= 0x10)){
3660                         idx = cfg->input_pins[i] - 0x09;
3661                         err = new_analog_input(spec, cfg->input_pins[i],
3662                                                auto_pin_cfg_labels[i], idx, 0x07);
3663                         if (err < 0)
3664                                 return err;
3665                         imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3666                         imux->items[imux->num_items].index = idx;
3667                         imux->num_items++;
3668                 }
3669         }
3670         return 0;
3671 }
3672
3673 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
3674                                               hda_nid_t nid, int pin_type,
3675                                               int sel_idx)
3676 {
3677         /* set as output */
3678         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
3679         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
3680         /* need the manual connection? */
3681         if (nid >= 0x12) {
3682                 int idx = nid - 0x12;
3683                 snd_hda_codec_write(codec, idx + 0x0b, 0,
3684                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
3685                                     
3686         }
3687 }
3688
3689 static void alc260_auto_init_multi_out(struct hda_codec *codec)
3690 {
3691         struct alc_spec *spec = codec->spec;
3692         hda_nid_t nid;
3693
3694         nid = spec->autocfg.line_out_pins[0];   
3695         if (nid)
3696                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3697         
3698         nid = spec->autocfg.speaker_pins[0];
3699         if (nid)
3700                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3701
3702         nid = spec->autocfg.hp_pin;
3703         if (nid)
3704                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
3705 }       
3706
3707 #define ALC260_PIN_CD_NID               0x16
3708 static void alc260_auto_init_analog_input(struct hda_codec *codec)
3709 {
3710         struct alc_spec *s