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