Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/davej/cpufreq
[linux-2.6.git] / sound / pci / hda / patch_realtek.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for ALC 260/880/882 codecs
5  *
6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
7  *                    PeiSen Hou <pshou@realtek.com.tw>
8  *                    Takashi Iwai <tiwai@suse.de>
9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
10  *
11  *  This driver is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *
16  *  This driver is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
24  */
25
26 #include <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
34 #define ALC880_FRONT_EVENT              0x01
35 #define ALC880_DCVOL_EVENT              0x02
36 #define ALC880_HP_EVENT                 0x04
37 #define ALC880_MIC_EVENT                0x08
38
39 /* ALC880 board config type */
40 enum {
41         ALC880_3ST,
42         ALC880_3ST_DIG,
43         ALC880_5ST,
44         ALC880_5ST_DIG,
45         ALC880_W810,
46         ALC880_Z71V,
47         ALC880_6ST,
48         ALC880_6ST_DIG,
49         ALC880_F1734,
50         ALC880_ASUS,
51         ALC880_ASUS_DIG,
52         ALC880_ASUS_W1V,
53         ALC880_ASUS_DIG2,
54         ALC880_FUJITSU,
55         ALC880_UNIWILL_DIG,
56         ALC880_UNIWILL,
57         ALC880_UNIWILL_P53,
58         ALC880_CLEVO,
59         ALC880_TCL_S700,
60         ALC880_LG,
61         ALC880_LG_LW,
62         ALC880_MEDION_RIM,
63 #ifdef CONFIG_SND_DEBUG
64         ALC880_TEST,
65 #endif
66         ALC880_AUTO,
67         ALC880_MODEL_LAST /* last tag */
68 };
69
70 /* ALC260 models */
71 enum {
72         ALC260_BASIC,
73         ALC260_HP,
74         ALC260_HP_DC7600,
75         ALC260_HP_3013,
76         ALC260_FUJITSU_S702X,
77         ALC260_ACER,
78         ALC260_WILL,
79         ALC260_REPLACER_672V,
80 #ifdef CONFIG_SND_DEBUG
81         ALC260_TEST,
82 #endif
83         ALC260_AUTO,
84         ALC260_MODEL_LAST /* last tag */
85 };
86
87 /* ALC262 models */
88 enum {
89         ALC262_BASIC,
90         ALC262_HIPPO,
91         ALC262_HIPPO_1,
92         ALC262_FUJITSU,
93         ALC262_HP_BPC,
94         ALC262_HP_BPC_D7000_WL,
95         ALC262_HP_BPC_D7000_WF,
96         ALC262_HP_TC_T5735,
97         ALC262_HP_RP5700,
98         ALC262_BENQ_ED8,
99         ALC262_SONY_ASSAMD,
100         ALC262_BENQ_T31,
101         ALC262_ULTRA,
102         ALC262_LENOVO_3000,
103         ALC262_NEC,
104         ALC262_TOSHIBA_S06,
105         ALC262_TOSHIBA_RX1,
106         ALC262_AUTO,
107         ALC262_MODEL_LAST /* last tag */
108 };
109
110 /* ALC268 models */
111 enum {
112         ALC267_QUANTA_IL1,
113         ALC268_3ST,
114         ALC268_TOSHIBA,
115         ALC268_ACER,
116         ALC268_ACER_DMIC,
117         ALC268_ACER_ASPIRE_ONE,
118         ALC268_DELL,
119         ALC268_ZEPTO,
120 #ifdef CONFIG_SND_DEBUG
121         ALC268_TEST,
122 #endif
123         ALC268_AUTO,
124         ALC268_MODEL_LAST /* last tag */
125 };
126
127 /* ALC269 models */
128 enum {
129         ALC269_BASIC,
130         ALC269_QUANTA_FL1,
131         ALC269_ASUS_EEEPC_P703,
132         ALC269_ASUS_EEEPC_P901,
133         ALC269_FUJITSU,
134         ALC269_LIFEBOOK,
135         ALC269_AUTO,
136         ALC269_MODEL_LAST /* last tag */
137 };
138
139 /* ALC861 models */
140 enum {
141         ALC861_3ST,
142         ALC660_3ST,
143         ALC861_3ST_DIG,
144         ALC861_6ST_DIG,
145         ALC861_UNIWILL_M31,
146         ALC861_TOSHIBA,
147         ALC861_ASUS,
148         ALC861_ASUS_LAPTOP,
149         ALC861_AUTO,
150         ALC861_MODEL_LAST,
151 };
152
153 /* ALC861-VD models */
154 enum {
155         ALC660VD_3ST,
156         ALC660VD_3ST_DIG,
157         ALC660VD_ASUS_V1S,
158         ALC861VD_3ST,
159         ALC861VD_3ST_DIG,
160         ALC861VD_6ST_DIG,
161         ALC861VD_LENOVO,
162         ALC861VD_DALLAS,
163         ALC861VD_HP,
164         ALC861VD_AUTO,
165         ALC861VD_MODEL_LAST,
166 };
167
168 /* ALC662 models */
169 enum {
170         ALC662_3ST_2ch_DIG,
171         ALC662_3ST_6ch_DIG,
172         ALC662_3ST_6ch,
173         ALC662_5ST_DIG,
174         ALC662_LENOVO_101E,
175         ALC662_ASUS_EEEPC_P701,
176         ALC662_ASUS_EEEPC_EP20,
177         ALC663_ASUS_M51VA,
178         ALC663_ASUS_G71V,
179         ALC663_ASUS_H13,
180         ALC663_ASUS_G50V,
181         ALC662_ECS,
182         ALC663_ASUS_MODE1,
183         ALC662_ASUS_MODE2,
184         ALC663_ASUS_MODE3,
185         ALC663_ASUS_MODE4,
186         ALC663_ASUS_MODE5,
187         ALC663_ASUS_MODE6,
188         ALC662_AUTO,
189         ALC662_MODEL_LAST,
190 };
191
192 /* ALC882 models */
193 enum {
194         ALC882_3ST_DIG,
195         ALC882_6ST_DIG,
196         ALC882_ARIMA,
197         ALC882_W2JC,
198         ALC882_TARGA,
199         ALC882_ASUS_A7J,
200         ALC882_ASUS_A7M,
201         ALC885_MACPRO,
202         ALC885_MBP3,
203         ALC885_IMAC24,
204         ALC882_AUTO,
205         ALC882_MODEL_LAST,
206 };
207
208 /* ALC883 models */
209 enum {
210         ALC883_3ST_2ch_DIG,
211         ALC883_3ST_6ch_DIG,
212         ALC883_3ST_6ch,
213         ALC883_6ST_DIG,
214         ALC883_TARGA_DIG,
215         ALC883_TARGA_2ch_DIG,
216         ALC883_ACER,
217         ALC883_ACER_ASPIRE,
218         ALC888_ACER_ASPIRE_4930G,
219         ALC883_MEDION,
220         ALC883_MEDION_MD2,
221         ALC883_LAPTOP_EAPD,
222         ALC883_LENOVO_101E_2ch,
223         ALC883_LENOVO_NB0763,
224         ALC888_LENOVO_MS7195_DIG,
225         ALC888_LENOVO_SKY,
226         ALC883_HAIER_W66,
227         ALC888_3ST_HP,
228         ALC888_6ST_DELL,
229         ALC883_MITAC,
230         ALC883_CLEVO_M720,
231         ALC883_FUJITSU_PI2515,
232         ALC888_FUJITSU_XA3530,
233         ALC883_3ST_6ch_INTEL,
234         ALC888_ASUS_M90V,
235         ALC888_ASUS_EEE1601,
236         ALC1200_ASUS_P5Q,
237         ALC883_AUTO,
238         ALC883_MODEL_LAST,
239 };
240
241 /* for GPIO Poll */
242 #define GPIO_MASK       0x03
243
244 struct alc_spec {
245         /* codec parameterization */
246         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
247         unsigned int num_mixers;
248         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
249
250         const struct hda_verb *init_verbs[5];   /* initialization verbs
251                                                  * don't forget NULL
252                                                  * termination!
253                                                  */
254         unsigned int num_init_verbs;
255
256         char *stream_name_analog;       /* analog PCM stream */
257         struct hda_pcm_stream *stream_analog_playback;
258         struct hda_pcm_stream *stream_analog_capture;
259         struct hda_pcm_stream *stream_analog_alt_playback;
260         struct hda_pcm_stream *stream_analog_alt_capture;
261
262         char *stream_name_digital;      /* digital PCM stream */
263         struct hda_pcm_stream *stream_digital_playback;
264         struct hda_pcm_stream *stream_digital_capture;
265
266         /* playback */
267         struct hda_multi_out multiout;  /* playback set-up
268                                          * max_channels, dacs must be set
269                                          * dig_out_nid and hp_nid are optional
270                                          */
271         hda_nid_t alt_dac_nid;
272
273         /* capture */
274         unsigned int num_adc_nids;
275         hda_nid_t *adc_nids;
276         hda_nid_t *capsrc_nids;
277         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
278         unsigned char is_mix_capture;   /* matrix-style capture (non-mux) */
279
280         /* capture source */
281         unsigned int num_mux_defs;
282         const struct hda_input_mux *input_mux;
283         unsigned int cur_mux[3];
284
285         /* channel model */
286         const struct hda_channel_mode *channel_mode;
287         int num_channel_mode;
288         int need_dac_fix;
289
290         /* PCM information */
291         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
292
293         /* dynamic controls, init_verbs and input_mux */
294         struct auto_pin_cfg autocfg;
295         struct snd_array kctls;
296         struct hda_input_mux private_imux;
297         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
298
299         /* hooks */
300         void (*init_hook)(struct hda_codec *codec);
301         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
302
303         /* for pin sensing */
304         unsigned int sense_updated: 1;
305         unsigned int jack_present: 1;
306         unsigned int master_sw: 1;
307
308         /* for virtual master */
309         hda_nid_t vmaster_nid;
310 #ifdef CONFIG_SND_HDA_POWER_SAVE
311         struct hda_loopback_check loopback;
312 #endif
313
314         /* for PLL fix */
315         hda_nid_t pll_nid;
316         unsigned int pll_coef_idx, pll_coef_bit;
317
318 #ifdef SND_HDA_NEEDS_RESUME
319 #define ALC_MAX_PINS    16
320         unsigned int num_pins;
321         hda_nid_t pin_nids[ALC_MAX_PINS];
322         unsigned int pin_cfgs[ALC_MAX_PINS];
323 #endif
324 };
325
326 /*
327  * configuration template - to be copied to the spec instance
328  */
329 struct alc_config_preset {
330         struct snd_kcontrol_new *mixers[5]; /* should be identical size
331                                              * with spec
332                                              */
333         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
334         const struct hda_verb *init_verbs[5];
335         unsigned int num_dacs;
336         hda_nid_t *dac_nids;
337         hda_nid_t dig_out_nid;          /* optional */
338         hda_nid_t hp_nid;               /* optional */
339         unsigned int num_adc_nids;
340         hda_nid_t *adc_nids;
341         hda_nid_t *capsrc_nids;
342         hda_nid_t dig_in_nid;
343         unsigned int num_channel_mode;
344         const struct hda_channel_mode *channel_mode;
345         int need_dac_fix;
346         unsigned int num_mux_defs;
347         const struct hda_input_mux *input_mux;
348         void (*unsol_event)(struct hda_codec *, unsigned int);
349         void (*init_hook)(struct hda_codec *);
350 #ifdef CONFIG_SND_HDA_POWER_SAVE
351         struct hda_amp_list *loopbacks;
352 #endif
353 };
354
355
356 /*
357  * input MUX handling
358  */
359 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
360                              struct snd_ctl_elem_info *uinfo)
361 {
362         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
363         struct alc_spec *spec = codec->spec;
364         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
365         if (mux_idx >= spec->num_mux_defs)
366                 mux_idx = 0;
367         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
368 }
369
370 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
371                             struct snd_ctl_elem_value *ucontrol)
372 {
373         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
374         struct alc_spec *spec = codec->spec;
375         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
376
377         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
378         return 0;
379 }
380
381 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
382                             struct snd_ctl_elem_value *ucontrol)
383 {
384         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
385         struct alc_spec *spec = codec->spec;
386         const struct hda_input_mux *imux;
387         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
388         unsigned int mux_idx;
389         hda_nid_t nid = spec->capsrc_nids ?
390                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
391
392         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
393         imux = &spec->input_mux[mux_idx];
394
395         if (spec->is_mix_capture) {
396                 /* Matrix-mixer style (e.g. ALC882) */
397                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
398                 unsigned int i, idx;
399
400                 idx = ucontrol->value.enumerated.item[0];
401                 if (idx >= imux->num_items)
402                         idx = imux->num_items - 1;
403                 if (*cur_val == idx)
404                         return 0;
405                 for (i = 0; i < imux->num_items; i++) {
406                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
407                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
408                                                  imux->items[i].index,
409                                                  HDA_AMP_MUTE, v);
410                 }
411                 *cur_val = idx;
412                 return 1;
413         } else {
414                 /* MUX style (e.g. ALC880) */
415                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
416                                              &spec->cur_mux[adc_idx]);
417         }
418 }
419
420 /*
421  * channel mode setting
422  */
423 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
424                             struct snd_ctl_elem_info *uinfo)
425 {
426         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
427         struct alc_spec *spec = codec->spec;
428         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
429                                     spec->num_channel_mode);
430 }
431
432 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
433                            struct snd_ctl_elem_value *ucontrol)
434 {
435         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
436         struct alc_spec *spec = codec->spec;
437         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
438                                    spec->num_channel_mode,
439                                    spec->multiout.max_channels);
440 }
441
442 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
443                            struct snd_ctl_elem_value *ucontrol)
444 {
445         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
446         struct alc_spec *spec = codec->spec;
447         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
448                                       spec->num_channel_mode,
449                                       &spec->multiout.max_channels);
450         if (err >= 0 && spec->need_dac_fix)
451                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
452         return err;
453 }
454
455 /*
456  * Control the mode of pin widget settings via the mixer.  "pc" is used
457  * instead of "%" to avoid consequences of accidently treating the % as
458  * being part of a format specifier.  Maximum allowed length of a value is
459  * 63 characters plus NULL terminator.
460  *
461  * Note: some retasking pin complexes seem to ignore requests for input
462  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
463  * are requested.  Therefore order this list so that this behaviour will not
464  * cause problems when mixer clients move through the enum sequentially.
465  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
466  * March 2006.
467  */
468 static char *alc_pin_mode_names[] = {
469         "Mic 50pc bias", "Mic 80pc bias",
470         "Line in", "Line out", "Headphone out",
471 };
472 static unsigned char alc_pin_mode_values[] = {
473         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
474 };
475 /* The control can present all 5 options, or it can limit the options based
476  * in the pin being assumed to be exclusively an input or an output pin.  In
477  * addition, "input" pins may or may not process the mic bias option
478  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
479  * accept requests for bias as of chip versions up to March 2006) and/or
480  * wiring in the computer.
481  */
482 #define ALC_PIN_DIR_IN              0x00
483 #define ALC_PIN_DIR_OUT             0x01
484 #define ALC_PIN_DIR_INOUT           0x02
485 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
486 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
487
488 /* Info about the pin modes supported by the different pin direction modes.
489  * For each direction the minimum and maximum values are given.
490  */
491 static signed char alc_pin_mode_dir_info[5][2] = {
492         { 0, 2 },    /* ALC_PIN_DIR_IN */
493         { 3, 4 },    /* ALC_PIN_DIR_OUT */
494         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
495         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
496         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
497 };
498 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
499 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
500 #define alc_pin_mode_n_items(_dir) \
501         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
502
503 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
504                              struct snd_ctl_elem_info *uinfo)
505 {
506         unsigned int item_num = uinfo->value.enumerated.item;
507         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
508
509         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
510         uinfo->count = 1;
511         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
512
513         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
514                 item_num = alc_pin_mode_min(dir);
515         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
516         return 0;
517 }
518
519 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
520                             struct snd_ctl_elem_value *ucontrol)
521 {
522         unsigned int i;
523         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
524         hda_nid_t nid = kcontrol->private_value & 0xffff;
525         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
526         long *valp = ucontrol->value.integer.value;
527         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
528                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
529                                                  0x00);
530
531         /* Find enumerated value for current pinctl setting */
532         i = alc_pin_mode_min(dir);
533         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
534                 i++;
535         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
536         return 0;
537 }
538
539 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
540                             struct snd_ctl_elem_value *ucontrol)
541 {
542         signed int change;
543         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
544         hda_nid_t nid = kcontrol->private_value & 0xffff;
545         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
546         long val = *ucontrol->value.integer.value;
547         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
548                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
549                                                  0x00);
550
551         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
552                 val = alc_pin_mode_min(dir);
553
554         change = pinctl != alc_pin_mode_values[val];
555         if (change) {
556                 /* Set pin mode to that requested */
557                 snd_hda_codec_write_cache(codec, nid, 0,
558                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
559                                           alc_pin_mode_values[val]);
560
561                 /* Also enable the retasking pin's input/output as required
562                  * for the requested pin mode.  Enum values of 2 or less are
563                  * input modes.
564                  *
565                  * Dynamically switching the input/output buffers probably
566                  * reduces noise slightly (particularly on input) so we'll
567                  * do it.  However, having both input and output buffers
568                  * enabled simultaneously doesn't seem to be problematic if
569                  * this turns out to be necessary in the future.
570                  */
571                 if (val <= 2) {
572                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
573                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
574                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
575                                                  HDA_AMP_MUTE, 0);
576                 } else {
577                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
578                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
579                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
580                                                  HDA_AMP_MUTE, 0);
581                 }
582         }
583         return change;
584 }
585
586 #define ALC_PIN_MODE(xname, nid, dir) \
587         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
588           .info = alc_pin_mode_info, \
589           .get = alc_pin_mode_get, \
590           .put = alc_pin_mode_put, \
591           .private_value = nid | (dir<<16) }
592
593 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
594  * together using a mask with more than one bit set.  This control is
595  * currently used only by the ALC260 test model.  At this stage they are not
596  * needed for any "production" models.
597  */
598 #ifdef CONFIG_SND_DEBUG
599 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
600
601 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
602                              struct snd_ctl_elem_value *ucontrol)
603 {
604         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
605         hda_nid_t nid = kcontrol->private_value & 0xffff;
606         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
607         long *valp = ucontrol->value.integer.value;
608         unsigned int val = snd_hda_codec_read(codec, nid, 0,
609                                               AC_VERB_GET_GPIO_DATA, 0x00);
610
611         *valp = (val & mask) != 0;
612         return 0;
613 }
614 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
615                              struct snd_ctl_elem_value *ucontrol)
616 {
617         signed int change;
618         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
619         hda_nid_t nid = kcontrol->private_value & 0xffff;
620         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
621         long val = *ucontrol->value.integer.value;
622         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
623                                                     AC_VERB_GET_GPIO_DATA,
624                                                     0x00);
625
626         /* Set/unset the masked GPIO bit(s) as needed */
627         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
628         if (val == 0)
629                 gpio_data &= ~mask;
630         else
631                 gpio_data |= mask;
632         snd_hda_codec_write_cache(codec, nid, 0,
633                                   AC_VERB_SET_GPIO_DATA, gpio_data);
634
635         return change;
636 }
637 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
638         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
639           .info = alc_gpio_data_info, \
640           .get = alc_gpio_data_get, \
641           .put = alc_gpio_data_put, \
642           .private_value = nid | (mask<<16) }
643 #endif   /* CONFIG_SND_DEBUG */
644
645 /* A switch control to allow the enabling of the digital IO pins on the
646  * ALC260.  This is incredibly simplistic; the intention of this control is
647  * to provide something in the test model allowing digital outputs to be
648  * identified if present.  If models are found which can utilise these
649  * outputs a more complete mixer control can be devised for those models if
650  * necessary.
651  */
652 #ifdef CONFIG_SND_DEBUG
653 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
654
655 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
656                               struct snd_ctl_elem_value *ucontrol)
657 {
658         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
659         hda_nid_t nid = kcontrol->private_value & 0xffff;
660         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
661         long *valp = ucontrol->value.integer.value;
662         unsigned int val = snd_hda_codec_read(codec, nid, 0,
663                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
664
665         *valp = (val & mask) != 0;
666         return 0;
667 }
668 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
669                               struct snd_ctl_elem_value *ucontrol)
670 {
671         signed int change;
672         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
673         hda_nid_t nid = kcontrol->private_value & 0xffff;
674         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
675         long val = *ucontrol->value.integer.value;
676         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
677                                                     AC_VERB_GET_DIGI_CONVERT_1,
678                                                     0x00);
679
680         /* Set/unset the masked control bit(s) as needed */
681         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
682         if (val==0)
683                 ctrl_data &= ~mask;
684         else
685                 ctrl_data |= mask;
686         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
687                                   ctrl_data);
688
689         return change;
690 }
691 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
692         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
693           .info = alc_spdif_ctrl_info, \
694           .get = alc_spdif_ctrl_get, \
695           .put = alc_spdif_ctrl_put, \
696           .private_value = nid | (mask<<16) }
697 #endif   /* CONFIG_SND_DEBUG */
698
699 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
700  * Again, this is only used in the ALC26x test models to help identify when
701  * the EAPD line must be asserted for features to work.
702  */
703 #ifdef CONFIG_SND_DEBUG
704 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
705
706 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
707                               struct snd_ctl_elem_value *ucontrol)
708 {
709         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
710         hda_nid_t nid = kcontrol->private_value & 0xffff;
711         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
712         long *valp = ucontrol->value.integer.value;
713         unsigned int val = snd_hda_codec_read(codec, nid, 0,
714                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
715
716         *valp = (val & mask) != 0;
717         return 0;
718 }
719
720 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
721                               struct snd_ctl_elem_value *ucontrol)
722 {
723         int change;
724         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
725         hda_nid_t nid = kcontrol->private_value & 0xffff;
726         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
727         long val = *ucontrol->value.integer.value;
728         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
729                                                     AC_VERB_GET_EAPD_BTLENABLE,
730                                                     0x00);
731
732         /* Set/unset the masked control bit(s) as needed */
733         change = (!val ? 0 : mask) != (ctrl_data & mask);
734         if (!val)
735                 ctrl_data &= ~mask;
736         else
737                 ctrl_data |= mask;
738         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
739                                   ctrl_data);
740
741         return change;
742 }
743
744 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
745         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
746           .info = alc_eapd_ctrl_info, \
747           .get = alc_eapd_ctrl_get, \
748           .put = alc_eapd_ctrl_put, \
749           .private_value = nid | (mask<<16) }
750 #endif   /* CONFIG_SND_DEBUG */
751
752 /*
753  */
754 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
755 {
756         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
757                 return;
758         spec->mixers[spec->num_mixers++] = mix;
759 }
760
761 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
762 {
763         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
764                 return;
765         spec->init_verbs[spec->num_init_verbs++] = verb;
766 }
767
768 #ifdef CONFIG_PROC_FS
769 /*
770  * hook for proc
771  */
772 static void print_realtek_coef(struct snd_info_buffer *buffer,
773                                struct hda_codec *codec, hda_nid_t nid)
774 {
775         int coeff;
776
777         if (nid != 0x20)
778                 return;
779         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
780         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
781         coeff = snd_hda_codec_read(codec, nid, 0,
782                                    AC_VERB_GET_COEF_INDEX, 0);
783         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
784 }
785 #else
786 #define print_realtek_coef      NULL
787 #endif
788
789 /*
790  * set up from the preset table
791  */
792 static void setup_preset(struct alc_spec *spec,
793                          const struct alc_config_preset *preset)
794 {
795         int i;
796
797         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
798                 add_mixer(spec, preset->mixers[i]);
799         spec->cap_mixer = preset->cap_mixer;
800         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
801              i++)
802                 add_verb(spec, preset->init_verbs[i]);
803
804         spec->channel_mode = preset->channel_mode;
805         spec->num_channel_mode = preset->num_channel_mode;
806         spec->need_dac_fix = preset->need_dac_fix;
807
808         spec->multiout.max_channels = spec->channel_mode[0].channels;
809
810         spec->multiout.num_dacs = preset->num_dacs;
811         spec->multiout.dac_nids = preset->dac_nids;
812         spec->multiout.dig_out_nid = preset->dig_out_nid;
813         spec->multiout.hp_nid = preset->hp_nid;
814
815         spec->num_mux_defs = preset->num_mux_defs;
816         if (!spec->num_mux_defs)
817                 spec->num_mux_defs = 1;
818         spec->input_mux = preset->input_mux;
819
820         spec->num_adc_nids = preset->num_adc_nids;
821         spec->adc_nids = preset->adc_nids;
822         spec->capsrc_nids = preset->capsrc_nids;
823         spec->dig_in_nid = preset->dig_in_nid;
824
825         spec->unsol_event = preset->unsol_event;
826         spec->init_hook = preset->init_hook;
827 #ifdef CONFIG_SND_HDA_POWER_SAVE
828         spec->loopback.amplist = preset->loopbacks;
829 #endif
830 }
831
832 /* Enable GPIO mask and set output */
833 static struct hda_verb alc_gpio1_init_verbs[] = {
834         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
835         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
836         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
837         { }
838 };
839
840 static struct hda_verb alc_gpio2_init_verbs[] = {
841         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
842         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
843         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
844         { }
845 };
846
847 static struct hda_verb alc_gpio3_init_verbs[] = {
848         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
849         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
850         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
851         { }
852 };
853
854 /*
855  * Fix hardware PLL issue
856  * On some codecs, the analog PLL gating control must be off while
857  * the default value is 1.
858  */
859 static void alc_fix_pll(struct hda_codec *codec)
860 {
861         struct alc_spec *spec = codec->spec;
862         unsigned int val;
863
864         if (!spec->pll_nid)
865                 return;
866         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
867                             spec->pll_coef_idx);
868         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
869                                  AC_VERB_GET_PROC_COEF, 0);
870         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
871                             spec->pll_coef_idx);
872         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
873                             val & ~(1 << spec->pll_coef_bit));
874 }
875
876 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
877                              unsigned int coef_idx, unsigned int coef_bit)
878 {
879         struct alc_spec *spec = codec->spec;
880         spec->pll_nid = nid;
881         spec->pll_coef_idx = coef_idx;
882         spec->pll_coef_bit = coef_bit;
883         alc_fix_pll(codec);
884 }
885
886 static void alc_sku_automute(struct hda_codec *codec)
887 {
888         struct alc_spec *spec = codec->spec;
889         unsigned int present;
890         unsigned int hp_nid = spec->autocfg.hp_pins[0];
891         unsigned int sp_nid = spec->autocfg.speaker_pins[0];
892
893         /* need to execute and sync at first */
894         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
895         present = snd_hda_codec_read(codec, hp_nid, 0,
896                                      AC_VERB_GET_PIN_SENSE, 0);
897         spec->jack_present = (present & 0x80000000) != 0;
898         snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
899                             spec->jack_present ? 0 : PIN_OUT);
900 }
901
902 #if 0 /* it's broken in some acses -- temporarily disabled */
903 static void alc_mic_automute(struct hda_codec *codec)
904 {
905         struct alc_spec *spec = codec->spec;
906         unsigned int present;
907         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
908         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
909         unsigned int mix_nid = spec->capsrc_nids[0];
910         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
911
912         capsrc_idx_mic = mic_nid - 0x18;
913         capsrc_idx_fmic = fmic_nid - 0x18;
914         present = snd_hda_codec_read(codec, mic_nid, 0,
915                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
916         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
917                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
918         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
919                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
920         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
921                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
922 }
923 #else
924 #define alc_mic_automute(codec) /* NOP */
925 #endif /* disabled */
926
927 /* unsolicited event for HP jack sensing */
928 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
929 {
930         if (codec->vendor_id == 0x10ec0880)
931                 res >>= 28;
932         else
933                 res >>= 26;
934         if (res == ALC880_HP_EVENT)
935                 alc_sku_automute(codec);
936
937         if (res == ALC880_MIC_EVENT)
938                 alc_mic_automute(codec);
939 }
940
941 static void alc_inithook(struct hda_codec *codec)
942 {
943         alc_sku_automute(codec);
944         alc_mic_automute(codec);
945 }
946
947 /* additional initialization for ALC888 variants */
948 static void alc888_coef_init(struct hda_codec *codec)
949 {
950         unsigned int tmp;
951
952         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
953         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
954         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
955         if ((tmp & 0xf0) == 2)
956                 /* alc888S-VC */
957                 snd_hda_codec_read(codec, 0x20, 0,
958                                    AC_VERB_SET_PROC_COEF, 0x830);
959          else
960                  /* alc888-VB */
961                  snd_hda_codec_read(codec, 0x20, 0,
962                                     AC_VERB_SET_PROC_COEF, 0x3030);
963 }
964
965 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
966  *      31 ~ 16 :       Manufacture ID
967  *      15 ~ 8  :       SKU ID
968  *      7  ~ 0  :       Assembly ID
969  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
970  */
971 static void alc_subsystem_id(struct hda_codec *codec,
972                              unsigned int porta, unsigned int porte,
973                              unsigned int portd)
974 {
975         unsigned int ass, tmp, i;
976         unsigned nid;
977         struct alc_spec *spec = codec->spec;
978
979         ass = codec->subsystem_id & 0xffff;
980         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
981                 goto do_sku;
982
983         /*
984          * 31~30        : port conetcivity
985          * 29~21        : reserve
986          * 20           : PCBEEP input
987          * 19~16        : Check sum (15:1)
988          * 15~1         : Custom
989          * 0            : override
990         */
991         nid = 0x1d;
992         if (codec->vendor_id == 0x10ec0260)
993                 nid = 0x17;
994         ass = snd_hda_codec_read(codec, nid, 0,
995                                  AC_VERB_GET_CONFIG_DEFAULT, 0);
996         if (!(ass & 1) && !(ass & 0x100000))
997                 return;
998         if ((ass >> 30) != 1)   /* no physical connection */
999                 return;
1000
1001         /* check sum */
1002         tmp = 0;
1003         for (i = 1; i < 16; i++) {
1004                 if ((ass >> i) & 1)
1005                         tmp++;
1006         }
1007         if (((ass >> 16) & 0xf) != tmp)
1008                 return;
1009 do_sku:
1010         /*
1011          * 0 : override
1012          * 1 :  Swap Jack
1013          * 2 : 0 --> Desktop, 1 --> Laptop
1014          * 3~5 : External Amplifier control
1015          * 7~6 : Reserved
1016         */
1017         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1018         switch (tmp) {
1019         case 1:
1020                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1021                 break;
1022         case 3:
1023                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1024                 break;
1025         case 7:
1026                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1027                 break;
1028         case 5: /* set EAPD output high */
1029                 switch (codec->vendor_id) {
1030                 case 0x10ec0260:
1031                         snd_hda_codec_write(codec, 0x0f, 0,
1032                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1033                         snd_hda_codec_write(codec, 0x10, 0,
1034                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1035                         break;
1036                 case 0x10ec0262:
1037                 case 0x10ec0267:
1038                 case 0x10ec0268:
1039                 case 0x10ec0269:
1040                 case 0x10ec0660:
1041                 case 0x10ec0662:
1042                 case 0x10ec0663:
1043                 case 0x10ec0862:
1044                 case 0x10ec0889:
1045                         snd_hda_codec_write(codec, 0x14, 0,
1046                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1047                         snd_hda_codec_write(codec, 0x15, 0,
1048                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1049                         break;
1050                 }
1051                 switch (codec->vendor_id) {
1052                 case 0x10ec0260:
1053                         snd_hda_codec_write(codec, 0x1a, 0,
1054                                             AC_VERB_SET_COEF_INDEX, 7);
1055                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1056                                                  AC_VERB_GET_PROC_COEF, 0);
1057                         snd_hda_codec_write(codec, 0x1a, 0,
1058                                             AC_VERB_SET_COEF_INDEX, 7);
1059                         snd_hda_codec_write(codec, 0x1a, 0,
1060                                             AC_VERB_SET_PROC_COEF,
1061                                             tmp | 0x2010);
1062                         break;
1063                 case 0x10ec0262:
1064                 case 0x10ec0880:
1065                 case 0x10ec0882:
1066                 case 0x10ec0883:
1067                 case 0x10ec0885:
1068                 case 0x10ec0889:
1069                         snd_hda_codec_write(codec, 0x20, 0,
1070                                             AC_VERB_SET_COEF_INDEX, 7);
1071                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1072                                                  AC_VERB_GET_PROC_COEF, 0);
1073                         snd_hda_codec_write(codec, 0x20, 0,
1074                                             AC_VERB_SET_COEF_INDEX, 7);
1075                         snd_hda_codec_write(codec, 0x20, 0,
1076                                             AC_VERB_SET_PROC_COEF,
1077                                             tmp | 0x2010);
1078                         break;
1079                 case 0x10ec0888:
1080                         /*alc888_coef_init(codec);*/ /* called in alc_init() */
1081                         break;
1082                 case 0x10ec0267:
1083                 case 0x10ec0268:
1084                         snd_hda_codec_write(codec, 0x20, 0,
1085                                             AC_VERB_SET_COEF_INDEX, 7);
1086                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1087                                                  AC_VERB_GET_PROC_COEF, 0);
1088                         snd_hda_codec_write(codec, 0x20, 0,
1089                                             AC_VERB_SET_COEF_INDEX, 7);
1090                         snd_hda_codec_write(codec, 0x20, 0,
1091                                             AC_VERB_SET_PROC_COEF,
1092                                             tmp | 0x3000);
1093                         break;
1094                 }
1095         default:
1096                 break;
1097         }
1098
1099         /* is laptop or Desktop and enable the function "Mute internal speaker
1100          * when the external headphone out jack is plugged"
1101          */
1102         if (!(ass & 0x8000))
1103                 return;
1104         /*
1105          * 10~8 : Jack location
1106          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1107          * 14~13: Resvered
1108          * 15   : 1 --> enable the function "Mute internal speaker
1109          *              when the external headphone out jack is plugged"
1110          */
1111         if (!spec->autocfg.speaker_pins[0]) {
1112                 if (spec->autocfg.line_out_pins[0])
1113                         spec->autocfg.speaker_pins[0] =
1114                                 spec->autocfg.line_out_pins[0];
1115                 else
1116                         return;
1117         }
1118
1119         if (!spec->autocfg.hp_pins[0]) {
1120                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1121                 if (tmp == 0)
1122                         spec->autocfg.hp_pins[0] = porta;
1123                 else if (tmp == 1)
1124                         spec->autocfg.hp_pins[0] = porte;
1125                 else if (tmp == 2)
1126                         spec->autocfg.hp_pins[0] = portd;
1127                 else
1128                         return;
1129         }
1130         if (spec->autocfg.hp_pins[0])
1131                 snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
1132                         AC_VERB_SET_UNSOLICITED_ENABLE,
1133                         AC_USRSP_EN | ALC880_HP_EVENT);
1134
1135 #if 0 /* it's broken in some acses -- temporarily disabled */
1136         if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
1137                 spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
1138                 snd_hda_codec_write(codec,
1139                         spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
1140                         AC_VERB_SET_UNSOLICITED_ENABLE,
1141                         AC_USRSP_EN | ALC880_MIC_EVENT);
1142 #endif /* disabled */
1143
1144         spec->unsol_event = alc_sku_unsol_event;
1145 }
1146
1147 /*
1148  * Fix-up pin default configurations
1149  */
1150
1151 struct alc_pincfg {
1152         hda_nid_t nid;
1153         u32 val;
1154 };
1155
1156 static void alc_fix_pincfg(struct hda_codec *codec,
1157                            const struct snd_pci_quirk *quirk,
1158                            const struct alc_pincfg **pinfix)
1159 {
1160         const struct alc_pincfg *cfg;
1161
1162         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1163         if (!quirk)
1164                 return;
1165
1166         cfg = pinfix[quirk->value];
1167         for (; cfg->nid; cfg++) {
1168                 int i;
1169                 u32 val = cfg->val;
1170                 for (i = 0; i < 4; i++) {
1171                         snd_hda_codec_write(codec, cfg->nid, 0,
1172                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
1173                                     val & 0xff);
1174                         val >>= 8;
1175                 }
1176         }
1177 }
1178
1179 /*
1180  * ALC888
1181  */
1182
1183 /*
1184  * 2ch mode
1185  */
1186 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1187 /* Mic-in jack as mic in */
1188         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1189         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1190 /* Line-in jack as Line in */
1191         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1192         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1193 /* Line-Out as Front */
1194         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1195         { } /* end */
1196 };
1197
1198 /*
1199  * 4ch mode
1200  */
1201 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1202 /* Mic-in jack as mic in */
1203         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1204         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1205 /* Line-in jack as Surround */
1206         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1207         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1208 /* Line-Out as Front */
1209         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1210         { } /* end */
1211 };
1212
1213 /*
1214  * 6ch mode
1215  */
1216 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1217 /* Mic-in jack as CLFE */
1218         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1219         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1220 /* Line-in jack as Surround */
1221         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1222         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1223 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1224         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1225         { } /* end */
1226 };
1227
1228 /*
1229  * 8ch mode
1230  */
1231 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1232 /* Mic-in jack as CLFE */
1233         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1234         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1235 /* Line-in jack as Surround */
1236         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1237         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1238 /* Line-Out as Side */
1239         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1240         { } /* end */
1241 };
1242
1243 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1244         { 2, alc888_4ST_ch2_intel_init },
1245         { 4, alc888_4ST_ch4_intel_init },
1246         { 6, alc888_4ST_ch6_intel_init },
1247         { 8, alc888_4ST_ch8_intel_init },
1248 };
1249
1250 /*
1251  * ALC888 Fujitsu Siemens Amillo xa3530
1252  */
1253
1254 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1255 /* Front Mic: set to PIN_IN (empty by default) */
1256         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1257 /* Connect Internal HP to Front */
1258         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1259         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1260         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1261 /* Connect Bass HP to Front */
1262         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1263         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1264         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1265 /* Connect Line-Out side jack (SPDIF) to Side */
1266         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1267         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1268         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1269 /* Connect Mic jack to CLFE */
1270         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1271         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1272         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1273 /* Connect Line-in jack to Surround */
1274         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1275         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1276         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1277 /* Connect HP out jack to Front */
1278         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1279         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1280         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1281 /* Enable unsolicited event for HP jack and Line-out jack */
1282         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1283         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1284         {}
1285 };
1286
1287 static void alc888_fujitsu_xa3530_automute(struct hda_codec *codec)
1288 {
1289         unsigned int present;
1290         unsigned int bits;
1291         /* Line out presence */
1292         present = snd_hda_codec_read(codec, 0x17, 0,
1293                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1294         /* HP out presence */
1295         present = present || snd_hda_codec_read(codec, 0x1b, 0,
1296                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1297         bits = present ? HDA_AMP_MUTE : 0;
1298         /* Toggle internal speakers muting */
1299         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1300                                  HDA_AMP_MUTE, bits);
1301         /* Toggle internal bass muting */
1302         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
1303                                  HDA_AMP_MUTE, bits);
1304 }
1305
1306 static void alc888_fujitsu_xa3530_unsol_event(struct hda_codec *codec,
1307                 unsigned int res)
1308 {
1309         if (res >> 26 == ALC880_HP_EVENT)
1310                 alc888_fujitsu_xa3530_automute(codec);
1311 }
1312
1313
1314 /*
1315  * ALC888 Acer Aspire 4930G model
1316  */
1317
1318 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1319 /* Front Mic: set to PIN_IN (empty by default) */
1320         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1321 /* Unselect Front Mic by default in input mixer 3 */
1322         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1323 /* Enable unsolicited event for HP jack */
1324         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1325 /* Connect Internal HP to front */
1326         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1327         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1328         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1329 /* Connect HP out to front */
1330         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1331         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1332         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1333         { }
1334 };
1335
1336 static struct hda_input_mux alc888_2_capture_sources[2] = {
1337         /* Front mic only available on one ADC */
1338         {
1339                 .num_items = 4,
1340                 .items = {
1341                         { "Mic", 0x0 },
1342                         { "Line", 0x2 },
1343                         { "CD", 0x4 },
1344                         { "Front Mic", 0xb },
1345                 },
1346         },
1347         {
1348                 .num_items = 3,
1349                 .items = {
1350                         { "Mic", 0x0 },
1351                         { "Line", 0x2 },
1352                         { "CD", 0x4 },
1353                 },
1354         }
1355 };
1356
1357 static struct snd_kcontrol_new alc888_base_mixer[] = {
1358         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1359         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1360         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1361         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1362         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1363                 HDA_OUTPUT),
1364         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1365         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1366         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1367         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1368         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1369         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1370         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1371         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1372         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1373         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1374         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1375         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1376         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1377         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1378         { } /* end */
1379 };
1380
1381 static void alc888_acer_aspire_4930g_automute(struct hda_codec *codec)
1382 {
1383         unsigned int present;
1384         unsigned int bits;
1385         present = snd_hda_codec_read(codec, 0x15, 0,
1386                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1387         bits = present ? HDA_AMP_MUTE : 0;
1388         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
1389                                  HDA_AMP_MUTE, bits);
1390 }
1391
1392 static void alc888_acer_aspire_4930g_unsol_event(struct hda_codec *codec,
1393                 unsigned int res)
1394 {
1395         if (res >> 26 == ALC880_HP_EVENT)
1396                 alc888_acer_aspire_4930g_automute(codec);
1397 }
1398
1399 /*
1400  * ALC880 3-stack model
1401  *
1402  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1403  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1404  *                 F-Mic = 0x1b, HP = 0x19
1405  */
1406
1407 static hda_nid_t alc880_dac_nids[4] = {
1408         /* front, rear, clfe, rear_surr */
1409         0x02, 0x05, 0x04, 0x03
1410 };
1411
1412 static hda_nid_t alc880_adc_nids[3] = {
1413         /* ADC0-2 */
1414         0x07, 0x08, 0x09,
1415 };
1416
1417 /* The datasheet says the node 0x07 is connected from inputs,
1418  * but it shows zero connection in the real implementation on some devices.
1419  * Note: this is a 915GAV bug, fixed on 915GLV
1420  */
1421 static hda_nid_t alc880_adc_nids_alt[2] = {
1422         /* ADC1-2 */
1423         0x08, 0x09,
1424 };
1425
1426 #define ALC880_DIGOUT_NID       0x06
1427 #define ALC880_DIGIN_NID        0x0a
1428
1429 static struct hda_input_mux alc880_capture_source = {
1430         .num_items = 4,
1431         .items = {
1432                 { "Mic", 0x0 },
1433                 { "Front Mic", 0x3 },
1434                 { "Line", 0x2 },
1435                 { "CD", 0x4 },
1436         },
1437 };
1438
1439 /* channel source setting (2/6 channel selection for 3-stack) */
1440 /* 2ch mode */
1441 static struct hda_verb alc880_threestack_ch2_init[] = {
1442         /* set line-in to input, mute it */
1443         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1444         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1445         /* set mic-in to input vref 80%, mute it */
1446         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1447         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1448         { } /* end */
1449 };
1450
1451 /* 6ch mode */
1452 static struct hda_verb alc880_threestack_ch6_init[] = {
1453         /* set line-in to output, unmute it */
1454         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1455         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1456         /* set mic-in to output, unmute it */
1457         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1458         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1459         { } /* end */
1460 };
1461
1462 static struct hda_channel_mode alc880_threestack_modes[2] = {
1463         { 2, alc880_threestack_ch2_init },
1464         { 6, alc880_threestack_ch6_init },
1465 };
1466
1467 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1468         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1469         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1470         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1471         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1472         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1473         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1474         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1475         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1476         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1477         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1478         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1479         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1480         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1481         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1482         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1483         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1484         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1485         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1486         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1487         {
1488                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1489                 .name = "Channel Mode",
1490                 .info = alc_ch_mode_info,
1491                 .get = alc_ch_mode_get,
1492                 .put = alc_ch_mode_put,
1493         },
1494         { } /* end */
1495 };
1496
1497 /* capture mixer elements */
1498 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1499                             struct snd_ctl_elem_info *uinfo)
1500 {
1501         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1502         struct alc_spec *spec = codec->spec;
1503         int err;
1504
1505         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1506         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1507                                                       HDA_INPUT);
1508         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1509         mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
1510         return err;
1511 }
1512
1513 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1514                            unsigned int size, unsigned int __user *tlv)
1515 {
1516         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1517         struct alc_spec *spec = codec->spec;
1518         int err;
1519
1520         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1521         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1522                                                       HDA_INPUT);
1523         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1524         mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
1525         return err;
1526 }
1527
1528 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1529                              struct snd_ctl_elem_value *ucontrol);
1530
1531 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1532                                  struct snd_ctl_elem_value *ucontrol,
1533                                  getput_call_t func)
1534 {
1535         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1536         struct alc_spec *spec = codec->spec;
1537         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1538         int err;
1539
1540         mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
1541         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1542                                                       3, 0, HDA_INPUT);
1543         err = func(kcontrol, ucontrol);
1544         mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
1545         return err;
1546 }
1547
1548 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1549                            struct snd_ctl_elem_value *ucontrol)
1550 {
1551         return alc_cap_getput_caller(kcontrol, ucontrol,
1552                                      snd_hda_mixer_amp_volume_get);
1553 }
1554
1555 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1556                            struct snd_ctl_elem_value *ucontrol)
1557 {
1558         return alc_cap_getput_caller(kcontrol, ucontrol,
1559                                      snd_hda_mixer_amp_volume_put);
1560 }
1561
1562 /* capture mixer elements */
1563 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1564
1565 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1566                           struct snd_ctl_elem_value *ucontrol)
1567 {
1568         return alc_cap_getput_caller(kcontrol, ucontrol,
1569                                      snd_hda_mixer_amp_switch_get);
1570 }
1571
1572 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1573                           struct snd_ctl_elem_value *ucontrol)
1574 {
1575         return alc_cap_getput_caller(kcontrol, ucontrol,
1576                                      snd_hda_mixer_amp_switch_put);
1577 }
1578
1579 #define DEFINE_CAPMIX(num) \
1580 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1581         { \
1582                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1583                 .name = "Capture Switch", \
1584                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1585                 .count = num, \
1586                 .info = alc_cap_sw_info, \
1587                 .get = alc_cap_sw_get, \
1588                 .put = alc_cap_sw_put, \
1589         }, \
1590         { \
1591                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1592                 .name = "Capture Volume", \
1593                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1594                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1595                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1596                 .count = num, \
1597                 .info = alc_cap_vol_info, \
1598                 .get = alc_cap_vol_get, \
1599                 .put = alc_cap_vol_put, \
1600                 .tlv = { .c = alc_cap_vol_tlv }, \
1601         }, \
1602         { \
1603                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1604                 /* .name = "Capture Source", */ \
1605                 .name = "Input Source", \
1606                 .count = num, \
1607                 .info = alc_mux_enum_info, \
1608                 .get = alc_mux_enum_get, \
1609                 .put = alc_mux_enum_put, \
1610         }, \
1611         { } /* end */ \
1612 }
1613
1614 /* up to three ADCs */
1615 DEFINE_CAPMIX(1);
1616 DEFINE_CAPMIX(2);
1617 DEFINE_CAPMIX(3);
1618
1619
1620 /*
1621  * ALC880 5-stack model
1622  *
1623  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1624  *      Side = 0x02 (0xd)
1625  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1626  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1627  */
1628
1629 /* additional mixers to alc880_three_stack_mixer */
1630 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1631         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1632         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1633         { } /* end */
1634 };
1635
1636 /* channel source setting (6/8 channel selection for 5-stack) */
1637 /* 6ch mode */
1638 static struct hda_verb alc880_fivestack_ch6_init[] = {
1639         /* set line-in to input, mute it */
1640         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1641         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1642         { } /* end */
1643 };
1644
1645 /* 8ch mode */
1646 static struct hda_verb alc880_fivestack_ch8_init[] = {
1647         /* set line-in to output, unmute it */
1648         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1649         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1650         { } /* end */
1651 };
1652
1653 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1654         { 6, alc880_fivestack_ch6_init },
1655         { 8, alc880_fivestack_ch8_init },
1656 };
1657
1658
1659 /*
1660  * ALC880 6-stack model
1661  *
1662  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1663  *      Side = 0x05 (0x0f)
1664  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1665  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1666  */
1667
1668 static hda_nid_t alc880_6st_dac_nids[4] = {
1669         /* front, rear, clfe, rear_surr */
1670         0x02, 0x03, 0x04, 0x05
1671 };
1672
1673 static struct hda_input_mux alc880_6stack_capture_source = {
1674         .num_items = 4,
1675         .items = {
1676                 { "Mic", 0x0 },
1677                 { "Front Mic", 0x1 },
1678                 { "Line", 0x2 },
1679                 { "CD", 0x4 },
1680         },
1681 };
1682
1683 /* fixed 8-channels */
1684 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1685         { 8, NULL },
1686 };
1687
1688 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1689         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1690         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1691         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1692         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1693         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1694         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1695         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1696         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1697         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1698         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1699         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1700         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1701         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1702         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1703         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1704         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1705         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1706         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1707         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1708         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1709         {
1710                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1711                 .name = "Channel Mode",
1712                 .info = alc_ch_mode_info,
1713                 .get = alc_ch_mode_get,
1714                 .put = alc_ch_mode_put,
1715         },
1716         { } /* end */
1717 };
1718
1719
1720 /*
1721  * ALC880 W810 model
1722  *
1723  * W810 has rear IO for:
1724  * Front (DAC 02)
1725  * Surround (DAC 03)
1726  * Center/LFE (DAC 04)
1727  * Digital out (06)
1728  *
1729  * The system also has a pair of internal speakers, and a headphone jack.
1730  * These are both connected to Line2 on the codec, hence to DAC 02.
1731  *
1732  * There is a variable resistor to control the speaker or headphone
1733  * volume. This is a hardware-only device without a software API.
1734  *
1735  * Plugging headphones in will disable the internal speakers. This is
1736  * implemented in hardware, not via the driver using jack sense. In
1737  * a similar fashion, plugging into the rear socket marked "front" will
1738  * disable both the speakers and headphones.
1739  *
1740  * For input, there's a microphone jack, and an "audio in" jack.
1741  * These may not do anything useful with this driver yet, because I
1742  * haven't setup any initialization verbs for these yet...
1743  */
1744
1745 static hda_nid_t alc880_w810_dac_nids[3] = {
1746         /* front, rear/surround, clfe */
1747         0x02, 0x03, 0x04
1748 };
1749
1750 /* fixed 6 channels */
1751 static struct hda_channel_mode alc880_w810_modes[1] = {
1752         { 6, NULL }
1753 };
1754
1755 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
1756 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
1757         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1758         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1759         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1760         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1761         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1762         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1763         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1764         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1765         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1766         { } /* end */
1767 };
1768
1769
1770 /*
1771  * Z710V model
1772  *
1773  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
1774  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
1775  *                 Line = 0x1a
1776  */
1777
1778 static hda_nid_t alc880_z71v_dac_nids[1] = {
1779         0x02
1780 };
1781 #define ALC880_Z71V_HP_DAC      0x03
1782
1783 /* fixed 2 channels */
1784 static struct hda_channel_mode alc880_2_jack_modes[1] = {
1785         { 2, NULL }
1786 };
1787
1788 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
1789         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1790         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1791         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1792         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
1793         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1794         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1795         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1796         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1797         { } /* end */
1798 };
1799
1800
1801 /*
1802  * ALC880 F1734 model
1803  *
1804  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
1805  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
1806  */
1807
1808 static hda_nid_t alc880_f1734_dac_nids[1] = {
1809         0x03
1810 };
1811 #define ALC880_F1734_HP_DAC     0x02
1812
1813 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
1814         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1815         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1816         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1817         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1818         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1819         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1822         { } /* end */
1823 };
1824
1825 static struct hda_input_mux alc880_f1734_capture_source = {
1826         .num_items = 2,
1827         .items = {
1828                 { "Mic", 0x1 },
1829                 { "CD", 0x4 },
1830         },
1831 };
1832
1833
1834 /*
1835  * ALC880 ASUS model
1836  *
1837  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1838  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1839  *  Mic = 0x18, Line = 0x1a
1840  */
1841
1842 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
1843 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
1844
1845 static struct snd_kcontrol_new alc880_asus_mixer[] = {
1846         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1847         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1848         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1849         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1850         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1851         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1852         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1853         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1854         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1855         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1856         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1857         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1858         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1859         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1860         {
1861                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1862                 .name = "Channel Mode",
1863                 .info = alc_ch_mode_info,
1864                 .get = alc_ch_mode_get,
1865                 .put = alc_ch_mode_put,
1866         },
1867         { } /* end */
1868 };
1869
1870 /*
1871  * ALC880 ASUS W1V model
1872  *
1873  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
1874  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
1875  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
1876  */
1877
1878 /* additional mixers to alc880_asus_mixer */
1879 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
1880         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
1881         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
1882         { } /* end */
1883 };
1884
1885 /* additional mixers to alc880_asus_mixer */
1886 static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
1887         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1888         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1889         { } /* end */
1890 };
1891
1892 /* TCL S700 */
1893 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
1894         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1895         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1896         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
1897         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
1898         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
1899         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
1900         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
1901         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
1902         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
1903         { } /* end */
1904 };
1905
1906 /* Uniwill */
1907 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
1908         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1909         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1910         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1911         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1912         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1913         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1914         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1915         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1916         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1917         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1918         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1919         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1920         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1921         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1922         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1923         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1924         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
1925         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
1926         {
1927                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1928                 .name = "Channel Mode",
1929                 .info = alc_ch_mode_info,
1930                 .get = alc_ch_mode_get,
1931                 .put = alc_ch_mode_put,
1932         },
1933         { } /* end */
1934 };
1935
1936 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
1937         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1938         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1939         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1940         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1941         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1942         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1943         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1944         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1945         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1946         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1947         { } /* end */
1948 };
1949
1950 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
1951         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1952         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
1953         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1954         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
1955         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1956         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1957         { } /* end */
1958 };
1959
1960 /*
1961  * virtual master controls
1962  */
1963
1964 /*
1965  * slave controls for virtual master
1966  */
1967 static const char *alc_slave_vols[] = {
1968         "Front Playback Volume",
1969         "Surround Playback Volume",
1970         "Center Playback Volume",
1971         "LFE Playback Volume",
1972         "Side Playback Volume",
1973         "Headphone Playback Volume",
1974         "Speaker Playback Volume",
1975         "Mono Playback Volume",
1976         "Line-Out Playback Volume",
1977         "PCM Playback Volume",
1978         NULL,
1979 };
1980
1981 static const char *alc_slave_sws[] = {
1982         "Front Playback Switch",
1983         "Surround Playback Switch",
1984         "Center Playback Switch",
1985         "LFE Playback Switch",
1986         "Side Playback Switch",
1987         "Headphone Playback Switch",
1988         "Speaker Playback Switch",
1989         "Mono Playback Switch",
1990         "IEC958 Playback Switch",
1991         NULL,
1992 };
1993
1994 /*
1995  * build control elements
1996  */
1997
1998 static void alc_free_kctls(struct hda_codec *codec);
1999
2000 static int alc_build_controls(struct hda_codec *codec)
2001 {
2002         struct alc_spec *spec = codec->spec;
2003         int err;
2004         int i;
2005
2006         for (i = 0; i < spec->num_mixers; i++) {
2007                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2008                 if (err < 0)
2009                         return err;
2010         }
2011         if (spec->cap_mixer) {
2012                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2013                 if (err < 0)
2014                         return err;
2015         }
2016         if (spec->multiout.dig_out_nid) {
2017                 err = snd_hda_create_spdif_out_ctls(codec,
2018                                                     spec->multiout.dig_out_nid);
2019                 if (err < 0)
2020                         return err;
2021                 err = snd_hda_create_spdif_share_sw(codec,
2022                                                     &spec->multiout);
2023                 if (err < 0)
2024                         return err;
2025                 spec->multiout.share_spdif = 1;
2026         }
2027         if (spec->dig_in_nid) {
2028                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2029                 if (err < 0)
2030                         return err;
2031         }
2032
2033         /* if we have no master control, let's create it */
2034         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2035                 unsigned int vmaster_tlv[4];
2036                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2037                                         HDA_OUTPUT, vmaster_tlv);
2038                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2039                                           vmaster_tlv, alc_slave_vols);
2040                 if (err < 0)
2041                         return err;
2042         }
2043         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2044                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2045                                           NULL, alc_slave_sws);
2046                 if (err < 0)
2047                         return err;
2048         }
2049
2050         alc_free_kctls(codec); /* no longer needed */
2051         return 0;
2052 }
2053
2054
2055 /*
2056  * initialize the codec volumes, etc
2057  */
2058
2059 /*
2060  * generic initialization of ADC, input mixers and output mixers
2061  */
2062 static struct hda_verb alc880_volume_init_verbs[] = {
2063         /*
2064          * Unmute ADC0-2 and set the default input to mic-in
2065          */
2066         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2067         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2068         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2069         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2070         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2071         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2072
2073         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2074          * mixer widget
2075          * Note: PASD motherboards uses the Line In 2 as the input for front
2076          * panel mic (mic 2)
2077          */
2078         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2079         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2080         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2081         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2082         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2083         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2084         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2085         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2086
2087         /*
2088          * Set up output mixers (0x0c - 0x0f)
2089          */
2090         /* set vol=0 to output mixers */
2091         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2092         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2093         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2094         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2095         /* set up input amps for analog loopback */
2096         /* Amp Indices: DAC = 0, mixer = 1 */
2097         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2098         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2099         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2100         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2101         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2102         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2103         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2104         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2105
2106         { }
2107 };
2108
2109 /*
2110  * 3-stack pin configuration:
2111  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2112  */
2113 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2114         /*
2115          * preset connection lists of input pins
2116          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2117          */
2118         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2119         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2120         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2121
2122         /*
2123          * Set pin mode and muting
2124          */
2125         /* set front pin widgets 0x14 for output */
2126         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2127         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2128         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2129         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2130         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2131         /* Mic2 (as headphone out) for HP output */
2132         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2133         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2134         /* Line In pin widget for input */
2135         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2136         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2137         /* Line2 (as front mic) pin widget for input and vref at 80% */
2138         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2139         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2140         /* CD pin widget for input */
2141         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2142
2143         { }
2144 };
2145
2146 /*
2147  * 5-stack pin configuration:
2148  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2149  * line-in/side = 0x1a, f-mic = 0x1b
2150  */
2151 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2152         /*
2153          * preset connection lists of input pins
2154          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2155          */
2156         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2157         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2158
2159         /*
2160          * Set pin mode and muting
2161          */
2162         /* set pin widgets 0x14-0x17 for output */
2163         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2164         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2165         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2166         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2167         /* unmute pins for output (no gain on this amp) */
2168         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2169         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2170         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2171         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2172
2173         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2174         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2175         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2176         /* Mic2 (as headphone out) for HP output */
2177         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2178         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2179         /* Line In pin widget for input */
2180         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2181         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2182         /* Line2 (as front mic) pin widget for input and vref at 80% */
2183         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2184         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2185         /* CD pin widget for input */
2186         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2187
2188         { }
2189 };
2190
2191 /*
2192  * W810 pin configuration:
2193  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2194  */
2195 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2196         /* hphone/speaker input selector: front DAC */
2197         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2198
2199         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2200         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2201         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2202         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2203         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2204         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2205
2206         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2207         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2208
2209         { }
2210 };
2211
2212 /*
2213  * Z71V pin configuration:
2214  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2215  */
2216 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2217         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2218         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2219         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2220         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2221
2222         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2223         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2224         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2225         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2226
2227         { }
2228 };
2229
2230 /*
2231  * 6-stack pin configuration:
2232  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2233  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2234  */
2235 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2236         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2237
2238         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2239         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2240         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2241         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2242         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2243         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2244         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2245         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2246
2247         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2248         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2249         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2250         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2251         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2252         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2253         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2254         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2255         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2256
2257         { }
2258 };
2259
2260 /*
2261  * Uniwill pin configuration:
2262  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2263  * line = 0x1a
2264  */
2265 static struct hda_verb alc880_uniwill_init_verbs[] = {
2266         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2267
2268         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2269         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2270         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2271         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2272         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2273         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2274         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2275         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2276         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2277         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2278         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2279         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2280         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2281         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2282
2283         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2284         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2285         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2286         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2287         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2288         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2289         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2290         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2291         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2292
2293         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2294         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2295
2296         { }
2297 };
2298
2299 /*
2300 * Uniwill P53
2301 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2302  */
2303 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2304         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2305
2306         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2307         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2308         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2309         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2310         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2311         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2312         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2313         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2314         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2315         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2316         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2317         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2318
2319         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2320         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2321         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2322         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2323         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2324         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2325
2326         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2327         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2328
2329         { }
2330 };
2331
2332 static struct hda_verb alc880_beep_init_verbs[] = {
2333         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2334         { }
2335 };
2336
2337 /* toggle speaker-output according to the hp-jack state */
2338 static void alc880_uniwill_hp_automute(struct hda_codec *codec)
2339 {
2340         unsigned int present;
2341         unsigned char bits;
2342
2343         present = snd_hda_codec_read(codec, 0x14, 0,
2344                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2345         bits = present ? HDA_AMP_MUTE : 0;
2346         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
2347                                  HDA_AMP_MUTE, bits);
2348         snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
2349                                  HDA_AMP_MUTE, bits);
2350 }
2351
2352 /* auto-toggle front mic */
2353 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2354 {
2355         unsigned int present;
2356         unsigned char bits;
2357
2358         present = snd_hda_codec_read(codec, 0x18, 0,
2359                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2360         bits = present ? HDA_AMP_MUTE : 0;
2361         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2362 }
2363
2364 static void alc880_uniwill_automute(struct hda_codec *codec)
2365 {
2366         alc880_uniwill_hp_automute(codec);
2367         alc880_uniwill_mic_automute(codec);
2368 }
2369
2370 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2371                                        unsigned int res)
2372 {
2373         /* Looks like the unsol event is incompatible with the standard
2374          * definition.  4bit tag is placed at 28 bit!
2375          */
2376         switch (res >> 28) {
2377         case ALC880_HP_EVENT:
2378                 alc880_uniwill_hp_automute(codec);
2379                 break;
2380         case ALC880_MIC_EVENT:
2381                 alc880_uniwill_mic_automute(codec);
2382                 break;
2383         }
2384 }
2385
2386 static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
2387 {
2388         unsigned int present;
2389         unsigned char bits;
2390
2391         present = snd_hda_codec_read(codec, 0x14, 0,
2392                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2393         bits = present ? HDA_AMP_MUTE : 0;
2394         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
2395 }
2396
2397 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2398 {
2399         unsigned int present;
2400
2401         present = snd_hda_codec_read(codec, 0x21, 0,
2402                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2403         present &= HDA_AMP_VOLMASK;
2404         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2405                                  HDA_AMP_VOLMASK, present);
2406         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2407                                  HDA_AMP_VOLMASK, present);
2408 }
2409
2410 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2411                                            unsigned int res)
2412 {
2413         /* Looks like the unsol event is incompatible with the standard
2414          * definition.  4bit tag is placed at 28 bit!
2415          */
2416         if ((res >> 28) == ALC880_HP_EVENT)
2417                 alc880_uniwill_p53_hp_automute(codec);
2418         if ((res >> 28) == ALC880_DCVOL_EVENT)
2419                 alc880_uniwill_p53_dcvol_automute(codec);
2420 }
2421
2422 /*
2423  * F1734 pin configuration:
2424  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2425  */
2426 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2427         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2428         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2429         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2430         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2431         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2432
2433         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2434         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2435         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2436         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2437
2438         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2439         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2440         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2441         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2442         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2443         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2444         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2445         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2446         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2447
2448         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2449         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2450
2451         { }
2452 };
2453
2454 /*
2455  * ASUS pin configuration:
2456  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2457  */
2458 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2459         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2460         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2461         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2462         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2463
2464         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2465         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2466         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2467         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2468         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2469         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2470         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2471         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2472
2473         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2474         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2475         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2476         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2477         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2478         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2479         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2480         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2481         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2482
2483         { }
2484 };
2485
2486 /* Enable GPIO mask and set output */
2487 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2488 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2489
2490 /* Clevo m520g init */
2491 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2492         /* headphone output */
2493         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2494         /* line-out */
2495         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2496         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2497         /* Line-in */
2498         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2499         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2500         /* CD */
2501         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2502         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2503         /* Mic1 (rear panel) */
2504         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2505         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2506         /* Mic2 (front panel) */
2507         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2508         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2509         /* headphone */
2510         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2511         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2512         /* change to EAPD mode */
2513         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2514         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2515
2516         { }
2517 };
2518
2519 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2520         /* change to EAPD mode */
2521         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2522         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2523
2524         /* Headphone output */
2525         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2526         /* Front output*/
2527         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2528         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2529
2530         /* Line In pin widget for input */
2531         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2532         /* CD pin widget for input */
2533         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2534         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2535         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2536
2537         /* change to EAPD mode */
2538         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2539         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2540
2541         { }
2542 };
2543
2544 /*
2545  * LG m1 express dual
2546  *
2547  * Pin assignment:
2548  *   Rear Line-In/Out (blue): 0x14
2549  *   Build-in Mic-In: 0x15
2550  *   Speaker-out: 0x17
2551  *   HP-Out (green): 0x1b
2552  *   Mic-In/Out (red): 0x19
2553  *   SPDIF-Out: 0x1e
2554  */
2555
2556 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2557 static hda_nid_t alc880_lg_dac_nids[3] = {
2558         0x05, 0x02, 0x03
2559 };
2560
2561 /* seems analog CD is not working */
2562 static struct hda_input_mux alc880_lg_capture_source = {
2563         .num_items = 3,
2564         .items = {
2565                 { "Mic", 0x1 },
2566                 { "Line", 0x5 },
2567                 { "Internal Mic", 0x6 },
2568         },
2569 };
2570
2571 /* 2,4,6 channel modes */
2572 static struct hda_verb alc880_lg_ch2_init[] = {
2573         /* set line-in and mic-in to input */
2574         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2575         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2576         { }
2577 };
2578
2579 static struct hda_verb alc880_lg_ch4_init[] = {
2580         /* set line-in to out and mic-in to input */
2581         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2582         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2583         { }
2584 };
2585
2586 static struct hda_verb alc880_lg_ch6_init[] = {
2587         /* set line-in and mic-in to output */
2588         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2589         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2590         { }
2591 };
2592
2593 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2594         { 2, alc880_lg_ch2_init },
2595         { 4, alc880_lg_ch4_init },
2596         { 6, alc880_lg_ch6_init },
2597 };
2598
2599 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2600         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2601         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2602         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2603         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2604         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2605         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2606         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2607         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2608         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2609         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2610         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2611         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2612         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2613         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2614         {
2615                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2616                 .name = "Channel Mode",
2617                 .info = alc_ch_mode_info,
2618                 .get = alc_ch_mode_get,
2619                 .put = alc_ch_mode_put,
2620         },
2621         { } /* end */
2622 };
2623
2624 static struct hda_verb alc880_lg_init_verbs[] = {
2625         /* set capture source to mic-in */
2626         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2627         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2628         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2629         /* mute all amp mixer inputs */
2630         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2631         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2632         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2633         /* line-in to input */
2634         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2635         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2636         /* built-in mic */
2637         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2638         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2639         /* speaker-out */
2640         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2641         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2642         /* mic-in to input */
2643         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2644         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2645         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2646         /* HP-out */
2647         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2648         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2649         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2650         /* jack sense */
2651         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2652         { }
2653 };
2654
2655 /* toggle speaker-output according to the hp-jack state */
2656 static void alc880_lg_automute(struct hda_codec *codec)
2657 {
2658         unsigned int present;
2659         unsigned char bits;
2660
2661         present = snd_hda_codec_read(codec, 0x1b, 0,
2662                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2663         bits = present ? HDA_AMP_MUTE : 0;
2664         snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
2665                                  HDA_AMP_MUTE, bits);
2666 }
2667
2668 static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
2669 {
2670         /* Looks like the unsol event is incompatible with the standard
2671          * definition.  4bit tag is placed at 28 bit!
2672          */
2673         if ((res >> 28) == 0x01)
2674                 alc880_lg_automute(codec);
2675 }
2676
2677 /*
2678  * LG LW20
2679  *
2680  * Pin assignment:
2681  *   Speaker-out: 0x14
2682  *   Mic-In: 0x18
2683  *   Built-in Mic-In: 0x19
2684  *   Line-In: 0x1b
2685  *   HP-Out: 0x1a
2686  *   SPDIF-Out: 0x1e
2687  */
2688
2689 static struct hda_input_mux alc880_lg_lw_capture_source = {
2690         .num_items = 3,
2691         .items = {
2692                 { "Mic", 0x0 },
2693                 { "Internal Mic", 0x1 },
2694                 { "Line In", 0x2 },
2695         },
2696 };
2697
2698 #define alc880_lg_lw_modes alc880_threestack_modes
2699
2700 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2701         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2702         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2703         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2704         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2705         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2706         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2707         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2708         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2709         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2710         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2711         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2712         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2713         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2714         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2715         {
2716                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2717                 .name = "Channel Mode",
2718                 .info = alc_ch_mode_info,
2719                 .get = alc_ch_mode_get,
2720                 .put = alc_ch_mode_put,
2721         },
2722         { } /* end */
2723 };
2724
2725 static struct hda_verb alc880_lg_lw_init_verbs[] = {
2726         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2727         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2728         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2729
2730         /* set capture source to mic-in */
2731         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2732         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2733         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2734         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2735         /* speaker-out */
2736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2737         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2738         /* HP-out */
2739         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2740         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2741         /* mic-in to input */
2742         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2743         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2744         /* built-in mic */
2745         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2746         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2747         /* jack sense */
2748         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
2749         { }
2750 };
2751
2752 /* toggle speaker-output according to the hp-jack state */
2753 static void alc880_lg_lw_automute(struct hda_codec *codec)
2754 {
2755         unsigned int present;
2756         unsigned char bits;
2757
2758         present = snd_hda_codec_read(codec, 0x1b, 0,
2759                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2760         bits = present ? HDA_AMP_MUTE : 0;
2761         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
2762                                  HDA_AMP_MUTE, bits);
2763 }
2764
2765 static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
2766 {
2767         /* Looks like the unsol event is incompatible with the standard
2768          * definition.  4bit tag is placed at 28 bit!
2769          */
2770         if ((res >> 28) == 0x01)
2771                 alc880_lg_lw_automute(codec);
2772 }
2773
2774 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
2775         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2776         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
2777         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2778         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2779         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2780         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
2781         { } /* end */
2782 };
2783
2784 static struct hda_input_mux alc880_medion_rim_capture_source = {
2785         .num_items = 2,
2786         .items = {
2787                 { "Mic", 0x0 },
2788                 { "Internal Mic", 0x1 },
2789         },
2790 };
2791
2792 static struct hda_verb alc880_medion_rim_init_verbs[] = {
2793         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2794
2795         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2796         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2797
2798         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2799         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2800         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2801         /* Mic2 (as headphone out) for HP output */
2802         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2803         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2804         /* Internal Speaker */
2805         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2806         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2807
2808         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2809         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2810
2811         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2812         { }
2813 };
2814
2815 /* toggle speaker-output according to the hp-jack state */
2816 static void alc880_medion_rim_automute(struct hda_codec *codec)
2817 {
2818         unsigned int present;
2819         unsigned char bits;
2820
2821         present = snd_hda_codec_read(codec, 0x14, 0,
2822                                      AC_VERB_GET_PIN_SENSE, 0)
2823                 & AC_PINSENSE_PRESENCE;
2824         bits = present ? HDA_AMP_MUTE : 0;
2825         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
2826                                  HDA_AMP_MUTE, bits);
2827         if (present)
2828                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
2829         else
2830                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
2831 }
2832
2833 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
2834                                           unsigned int res)
2835 {
2836         /* Looks like the unsol event is incompatible with the standard
2837          * definition.  4bit tag is placed at 28 bit!
2838          */
2839         if ((res >> 28) == ALC880_HP_EVENT)
2840                 alc880_medion_rim_automute(codec);
2841 }
2842
2843 #ifdef CONFIG_SND_HDA_POWER_SAVE
2844 static struct hda_amp_list alc880_loopbacks[] = {
2845         { 0x0b, HDA_INPUT, 0 },
2846         { 0x0b, HDA_INPUT, 1 },
2847         { 0x0b, HDA_INPUT, 2 },
2848         { 0x0b, HDA_INPUT, 3 },
2849         { 0x0b, HDA_INPUT, 4 },
2850         { } /* end */
2851 };
2852
2853 static struct hda_amp_list alc880_lg_loopbacks[] = {
2854         { 0x0b, HDA_INPUT, 1 },
2855         { 0x0b, HDA_INPUT, 6 },
2856         { 0x0b, HDA_INPUT, 7 },
2857         { } /* end */
2858 };
2859 #endif
2860
2861 /*
2862  * Common callbacks
2863  */
2864
2865 static int alc_init(struct hda_codec *codec)
2866 {
2867         struct alc_spec *spec = codec->spec;
2868         unsigned int i;
2869
2870         alc_fix_pll(codec);
2871         if (codec->vendor_id == 0x10ec0888)
2872                 alc888_coef_init(codec);
2873
2874         for (i = 0; i < spec->num_init_verbs; i++)
2875                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2876
2877         if (spec->init_hook)
2878                 spec->init_hook(codec);
2879
2880         return 0;
2881 }
2882
2883 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
2884 {
2885         struct alc_spec *spec = codec->spec;
2886
2887         if (spec->unsol_event)
2888                 spec->unsol_event(codec, res);
2889 }
2890
2891 #ifdef CONFIG_SND_HDA_POWER_SAVE
2892 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2893 {
2894         struct alc_spec *spec = codec->spec;
2895         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2896 }
2897 #endif
2898
2899 /*
2900  * Analog playback callbacks
2901  */
2902 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
2903                                     struct hda_codec *codec,
2904                                     struct snd_pcm_substream *substream)
2905 {
2906         struct alc_spec *spec = codec->spec;
2907         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2908                                              hinfo);
2909 }
2910
2911 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2912                                        struct hda_codec *codec,
2913                                        unsigned int stream_tag,
2914                                        unsigned int format,
2915                                        struct snd_pcm_substream *substream)
2916 {
2917         struct alc_spec *spec = codec->spec;
2918         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
2919                                                 stream_tag, format, substream);
2920 }
2921
2922 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2923                                        struct hda_codec *codec,
2924                                        struct snd_pcm_substream *substream)
2925 {
2926         struct alc_spec *spec = codec->spec;
2927         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2928 }
2929
2930 /*
2931  * Digital out
2932  */
2933 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2934                                         struct hda_codec *codec,
2935                                         struct snd_pcm_substream *substream)
2936 {
2937         struct alc_spec *spec = codec->spec;
2938         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2939 }
2940
2941 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2942                                            struct hda_codec *codec,
2943                                            unsigned int stream_tag,
2944                                            unsigned int format,
2945                                            struct snd_pcm_substream *substream)
2946 {
2947         struct alc_spec *spec = codec->spec;
2948         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2949                                              stream_tag, format, substream);
2950 }
2951
2952 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2953                                          struct hda_codec *codec,
2954                                          struct snd_pcm_substream *substream)
2955 {
2956         struct alc_spec *spec = codec->spec;
2957         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2958 }
2959
2960 /*
2961  * Analog capture
2962  */
2963 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2964                                       struct hda_codec *codec,
2965                                       unsigned int stream_tag,
2966                                       unsigned int format,
2967                                       struct snd_pcm_substream *substream)
2968 {
2969         struct alc_spec *spec = codec->spec;
2970
2971         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
2972                                    stream_tag, 0, format);
2973         return 0;
2974 }
2975
2976 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2977                                       struct hda_codec *codec,
2978                                       struct snd_pcm_substream *substream)
2979 {
2980         struct alc_spec *spec = codec->spec;
2981
2982         snd_hda_codec_cleanup_stream(codec,
2983                                      spec->adc_nids[substream->number + 1]);
2984         return 0;
2985 }
2986
2987
2988 /*
2989  */
2990 static struct hda_pcm_stream alc880_pcm_analog_playback = {
2991         .substreams = 1,
2992         .channels_min = 2,
2993         .channels_max = 8,
2994         /* NID is set in alc_build_pcms */
2995         .ops = {
2996                 .open = alc880_playback_pcm_open,
2997                 .prepare = alc880_playback_pcm_prepare,
2998                 .cleanup = alc880_playback_pcm_cleanup
2999         },
3000 };
3001
3002 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3003         .substreams = 1,
3004         .channels_min = 2,
3005         .channels_max = 2,
3006         /* NID is set in alc_build_pcms */
3007 };
3008
3009 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3010         .substreams = 1,
3011         .channels_min = 2,
3012         .channels_max = 2,
3013         /* NID is set in alc_build_pcms */
3014 };
3015
3016 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3017         .substreams = 2, /* can be overridden */
3018         .channels_min = 2,
3019         .channels_max = 2,
3020         /* NID is set in alc_build_pcms */
3021         .ops = {
3022                 .prepare = alc880_alt_capture_pcm_prepare,
3023                 .cleanup = alc880_alt_capture_pcm_cleanup
3024         },
3025 };
3026
3027 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3028         .substreams = 1,
3029         .channels_min = 2,
3030         .channels_max = 2,
3031         /* NID is set in alc_build_pcms */
3032         .ops = {
3033                 .open = alc880_dig_playback_pcm_open,
3034                 .close = alc880_dig_playback_pcm_close,
3035                 .prepare = alc880_dig_playback_pcm_prepare
3036         },
3037 };
3038
3039 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3040         .substreams = 1,
3041         .channels_min = 2,
3042         .channels_max = 2,
3043         /* NID is set in alc_build_pcms */
3044 };
3045
3046 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3047 static struct hda_pcm_stream alc_pcm_null_stream = {
3048         .substreams = 0,
3049         .channels_min = 0,
3050         .channels_max = 0,
3051 };
3052
3053 static int alc_build_pcms(struct hda_codec *codec)
3054 {
3055         struct alc_spec *spec = codec->spec;
3056         struct hda_pcm *info = spec->pcm_rec;
3057         int i;
3058
3059         codec->num_pcms = 1;
3060         codec->pcm_info = info;
3061
3062         info->name = spec->stream_name_analog;
3063         if (spec->stream_analog_playback) {
3064                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3065                         return -EINVAL;
3066                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3067                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3068         }
3069         if (spec->stream_analog_capture) {
3070                 if (snd_BUG_ON(!spec->adc_nids))
3071                         return -EINVAL;
3072                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3073                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3074         }
3075
3076         if (spec->channel_mode) {
3077                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3078                 for (i = 0; i < spec->num_channel_mode; i++) {
3079                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3080                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3081                         }
3082                 }
3083         }
3084
3085         /* SPDIF for stream index #1 */
3086         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3087                 codec->num_pcms = 2;
3088                 info = spec->pcm_rec + 1;
3089                 info->name = spec->stream_name_digital;
3090                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
3091                 if (spec->multiout.dig_out_nid &&
3092                     spec->stream_digital_playback) {
3093                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3094                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3095                 }
3096                 if (spec->dig_in_nid &&
3097                     spec->stream_digital_capture) {
3098                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3099                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3100                 }
3101                 /* FIXME: do we need this for all Realtek codec models? */
3102                 codec->spdif_status_reset = 1;
3103         }
3104
3105         /* If the use of more than one ADC is requested for the current
3106          * model, configure a second analog capture-only PCM.
3107          */
3108         /* Additional Analaog capture for index #2 */
3109         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3110             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3111                 codec->num_pcms = 3;
3112                 info = spec->pcm_rec + 2;
3113                 info->name = spec->stream_name_analog;
3114                 if (spec->alt_dac_nid) {
3115                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3116                                 *spec->stream_analog_alt_playback;
3117                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3118                                 spec->alt_dac_nid;
3119                 } else {
3120                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3121                                 alc_pcm_null_stream;
3122                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3123                 }
3124                 if (spec->num_adc_nids > 1) {
3125                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3126                                 *spec->stream_analog_alt_capture;
3127                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3128                                 spec->adc_nids[1];
3129                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3130                                 spec->num_adc_nids - 1;
3131                 } else {
3132                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3133                                 alc_pcm_null_stream;
3134                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3135                 }
3136         }
3137
3138         return 0;
3139 }
3140
3141 static void alc_free_kctls(struct hda_codec *codec)
3142 {
3143         struct alc_spec *spec = codec->spec;
3144
3145         if (spec->kctls.list) {
3146                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3147                 int i;
3148                 for (i = 0; i < spec->kctls.used; i++)
3149                         kfree(kctl[i].name);
3150         }
3151         snd_array_free(&spec->kctls);
3152 }
3153
3154 static void alc_free(struct hda_codec *codec)
3155 {
3156         struct alc_spec *spec = codec->spec;
3157
3158         if (!spec)
3159                 return;
3160
3161         alc_free_kctls(codec);
3162         kfree(spec);
3163         codec->spec = NULL; /* to be sure */
3164 }
3165
3166 #ifdef SND_HDA_NEEDS_RESUME
3167 static void store_pin_configs(struct hda_codec *codec)
3168 {
3169         struct alc_spec *spec = codec->spec;
3170         hda_nid_t nid, end_nid;
3171
3172         end_nid = codec->start_nid + codec->num_nodes;
3173         for (nid = codec->start_nid; nid < end_nid; nid++) {
3174                 unsigned int wid_caps = get_wcaps(codec, nid);
3175                 unsigned int wid_type =
3176                         (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
3177                 if (wid_type != AC_WID_PIN)
3178                         continue;
3179                 if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
3180                         break;
3181                 spec->pin_nids[spec->num_pins] = nid;
3182                 spec->pin_cfgs[spec->num_pins] =
3183                         snd_hda_codec_read(codec, nid, 0,
3184                                            AC_VERB_GET_CONFIG_DEFAULT, 0);
3185                 spec->num_pins++;
3186         }
3187 }
3188
3189 static void resume_pin_configs(struct hda_codec *codec)
3190 {
3191         struct alc_spec *spec = codec->spec;
3192         int i;
3193
3194         for (i = 0; i < spec->num_pins; i++) {
3195                 hda_nid_t pin_nid = spec->pin_nids[i];
3196                 unsigned int pin_config = spec->pin_cfgs[i];
3197                 snd_hda_codec_write(codec, pin_nid, 0,
3198                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
3199                                     pin_config & 0x000000ff);
3200                 snd_hda_codec_write(codec, pin_nid, 0,
3201                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
3202                                     (pin_config & 0x0000ff00) >> 8);
3203                 snd_hda_codec_write(codec, pin_nid, 0,
3204                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
3205                                     (pin_config & 0x00ff0000) >> 16);
3206                 snd_hda_codec_write(codec, pin_nid, 0,
3207                                     AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
3208                                     pin_config >> 24);
3209         }
3210 }
3211
3212 static int alc_resume(struct hda_codec *codec)
3213 {
3214         resume_pin_configs(codec);
3215         codec->patch_ops.init(codec);
3216         snd_hda_codec_resume_amp(codec);
3217         snd_hda_codec_resume_cache(codec);
3218         return 0;
3219 }
3220 #else
3221 #define store_pin_configs(codec)
3222 #endif
3223
3224 /*
3225  */
3226 static struct hda_codec_ops alc_patch_ops = {
3227         .build_controls = alc_build_controls,
3228         .build_pcms = alc_build_pcms,
3229         .init = alc_init,
3230         .free = alc_free,
3231         .unsol_event = alc_unsol_event,
3232 #ifdef SND_HDA_NEEDS_RESUME
3233         .resume = alc_resume,
3234 #endif
3235 #ifdef CONFIG_SND_HDA_POWER_SAVE
3236         .check_power_status = alc_check_power_status,
3237 #endif
3238 };
3239
3240
3241 /*
3242  * Test configuration for debugging
3243  *
3244  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3245  * enum controls.
3246  */
3247 #ifdef CONFIG_SND_DEBUG
3248 static hda_nid_t alc880_test_dac_nids[4] = {
3249         0x02, 0x03, 0x04, 0x05
3250 };
3251
3252 static struct hda_input_mux alc880_test_capture_source = {
3253         .num_items = 7,
3254         .items = {
3255                 { "In-1", 0x0 },
3256                 { "In-2", 0x1 },
3257                 { "In-3", 0x2 },
3258                 { "In-4", 0x3 },
3259                 { "CD", 0x4 },
3260                 { "Front", 0x5 },
3261                 { "Surround", 0x6 },
3262         },
3263 };
3264
3265 static struct hda_channel_mode alc880_test_modes[4] = {
3266         { 2, NULL },
3267         { 4, NULL },
3268         { 6, NULL },
3269         { 8, NULL },
3270 };
3271
3272 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3273                                  struct snd_ctl_elem_info *uinfo)
3274 {
3275         static char *texts[] = {
3276                 "N/A", "Line Out", "HP Out",
3277                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3278         };
3279         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3280         uinfo->count = 1;
3281         uinfo->value.enumerated.items = 8;
3282         if (uinfo->value.enumerated.item >= 8)
3283                 uinfo->value.enumerated.item = 7;
3284         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3285         return 0;
3286 }
3287
3288 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3289                                 struct snd_ctl_elem_value *ucontrol)
3290 {
3291         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3292         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3293         unsigned int pin_ctl, item = 0;
3294
3295         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3296                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3297         if (pin_ctl & AC_PINCTL_OUT_EN) {
3298                 if (pin_ctl & AC_PINCTL_HP_EN)
3299                         item = 2;
3300                 else
3301                         item = 1;
3302         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3303                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3304                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3305                 case AC_PINCTL_VREF_50:  item = 4; break;
3306                 case AC_PINCTL_VREF_GRD: item = 5; break;
3307                 case AC_PINCTL_VREF_80:  item = 6; break;
3308                 case AC_PINCTL_VREF_100: item = 7; break;
3309                 }
3310         }
3311         ucontrol->value.enumerated.item[0] = item;
3312         return 0;
3313 }
3314
3315 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3316                                 struct snd_ctl_elem_value *ucontrol)
3317 {
3318         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3319         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3320         static unsigned int ctls[] = {
3321                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3322                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3323                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3324                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3325                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3326                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3327         };
3328         unsigned int old_ctl, new_ctl;
3329
3330         old_ctl = snd_hda_codec_read(codec, nid, 0,
3331                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3332         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3333         if (old_ctl != new_ctl) {
3334                 int val;
3335                 snd_hda_codec_write_cache(codec, nid, 0,
3336                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3337                                           new_ctl);
3338                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3339                         HDA_AMP_MUTE : 0;
3340                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3341                                          HDA_AMP_MUTE, val);
3342                 return 1;
3343         }
3344         return 0;
3345 }
3346
3347 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3348                                  struct snd_ctl_elem_info *uinfo)
3349 {
3350         static char *texts[] = {
3351                 "Front", "Surround", "CLFE", "Side"
3352         };
3353         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3354         uinfo->count = 1;
3355         uinfo->value.enumerated.items = 4;
3356         if (uinfo->value.enumerated.item >= 4)
3357                 uinfo->value.enumerated.item = 3;
3358         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3359         return 0;
3360 }
3361
3362 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3363                                 struct snd_ctl_elem_value *ucontrol)
3364 {
3365         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3366         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3367         unsigned int sel;
3368
3369         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3370         ucontrol->value.enumerated.item[0] = sel & 3;
3371         return 0;
3372 }
3373
3374 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3375                                 struct snd_ctl_elem_value *ucontrol)
3376 {
3377         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3378         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3379         unsigned int sel;
3380
3381         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3382         if (ucontrol->value.enumerated.item[0] != sel) {
3383                 sel = ucontrol->value.enumerated.item[0] & 3;
3384                 snd_hda_codec_write_cache(codec, nid, 0,
3385                                           AC_VERB_SET_CONNECT_SEL, sel);
3386                 return 1;
3387         }
3388         return 0;
3389 }
3390
3391 #define PIN_CTL_TEST(xname,nid) {                       \
3392                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3393                         .name = xname,                 \
3394                         .info = alc_test_pin_ctl_info, \
3395                         .get = alc_test_pin_ctl_get,   \
3396                         .put = alc_test_pin_ctl_put,   \
3397                         .private_value = nid           \
3398                         }
3399
3400 #define PIN_SRC_TEST(xname,nid) {                       \
3401                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3402                         .name = xname,                 \
3403                         .info = alc_test_pin_src_info, \
3404                         .get = alc_test_pin_src_get,   \
3405                         .put = alc_test_pin_src_put,   \
3406                         .private_value = nid           \
3407                         }
3408
3409 static struct snd_kcontrol_new alc880_test_mixer[] = {
3410         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3411         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3412         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3413         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3414         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3415         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3416         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3417         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3418         PIN_CTL_TEST("Front Pin Mode", 0x14),
3419         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3420         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3421         PIN_CTL_TEST("Side Pin Mode", 0x17),
3422         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3423         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3424         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3425         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3426         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3427         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3428         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3429         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3430         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3431         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3432         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3433         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3434         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3435         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3436         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3437         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3438         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3439         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3440         {
3441                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3442                 .name = "Channel Mode",
3443                 .info = alc_ch_mode_info,
3444                 .get = alc_ch_mode_get,
3445                 .put = alc_ch_mode_put,
3446         },
3447         { } /* end */
3448 };
3449
3450 static struct hda_verb alc880_test_init_verbs[] = {
3451         /* Unmute inputs of 0x0c - 0x0f */
3452         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3453         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3454         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3455         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3456         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3457         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3458         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3459         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3460         /* Vol output for 0x0c-0x0f */
3461         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3462         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3463         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3464         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3465         /* Set output pins 0x14-0x17 */
3466         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3467         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3468         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3469         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3470         /* Unmute output pins 0x14-0x17 */
3471         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3472         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3473         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3474         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3475         /* Set input pins 0x18-0x1c */
3476         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3477         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3478         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3479         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3480         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3481         /* Mute input pins 0x18-0x1b */
3482         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3483         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3484         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3485         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3486         /* ADC set up */
3487         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3488         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3489         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3490         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3491         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3492         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3493         /* Analog input/passthru */
3494         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3495         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3496         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3497         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3498         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3499         { }
3500 };
3501 #endif
3502
3503 /*
3504  */
3505
3506 static const char *alc880_models[ALC880_MODEL_LAST] = {
3507         [ALC880_3ST]            = "3stack",
3508         [ALC880_TCL_S700]       = "tcl",
3509         [ALC880_3ST_DIG]        = "3stack-digout",
3510         [ALC880_CLEVO]          = "clevo",
3511         [ALC880_5ST]            = "5stack",
3512         [ALC880_5ST_DIG]        = "5stack-digout",
3513         [ALC880_W810]           = "w810",
3514         [ALC880_Z71V]           = "z71v",
3515         [ALC880_6ST]            = "6stack",
3516         [ALC880_6ST_DIG]        = "6stack-digout",
3517         [ALC880_ASUS]           = "asus",
3518         [ALC880_ASUS_W1V]       = "asus-w1v",
3519         [ALC880_ASUS_DIG]       = "asus-dig",
3520         [ALC880_ASUS_DIG2]      = "asus-dig2",
3521         [ALC880_UNIWILL_DIG]    = "uniwill",
3522         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3523         [ALC880_FUJITSU]        = "fujitsu",
3524         [ALC880_F1734]          = "F1734",
3525         [ALC880_LG]             = "lg",
3526         [ALC880_LG_LW]          = "lg-lw",
3527         [ALC880_MEDION_RIM]     = "medion",
3528 #ifdef CONFIG_SND_DEBUG
3529         [ALC880_TEST]           = "test",
3530 #endif
3531         [ALC880_AUTO]           = "auto",
3532 };
3533
3534 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3535         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3536         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3537         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3538         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3539         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3540         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3541         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3542         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3543         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3544         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3545         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3546         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3547         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3548         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3549         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3550         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3551         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3552         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3553         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3554         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3555         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3556         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3557         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3558         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3559         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3560         SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
3561         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3562         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3563         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3564         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3565         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3566         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3567         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3568         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3569         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3570         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3571         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3572         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3573         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3574         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3575         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3576         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3577         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3578         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3579         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3580         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3581         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3582         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3583         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3584         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3585         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3586         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3587         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3588         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3589         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3590         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3591         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3592         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3593         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3594         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3595         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3596         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3597         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3598         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3599         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3600         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3601         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3602         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3603         SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
3604         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3605         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3606         {}
3607 };
3608
3609 /*
3610  * ALC880 codec presets
3611  */
3612 static struct alc_config_preset alc880_presets[] = {
3613         [ALC880_3ST] = {
3614                 .mixers = { alc880_three_stack_mixer },
3615                 .init_verbs = { alc880_volume_init_verbs,
3616                                 alc880_pin_3stack_init_verbs },
3617                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3618                 .dac_nids = alc880_dac_nids,
3619                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3620                 .channel_mode = alc880_threestack_modes,
3621                 .need_dac_fix = 1,
3622                 .input_mux = &alc880_capture_source,
3623         },
3624         [ALC880_3ST_DIG] = {
3625                 .mixers = { alc880_three_stack_mixer },
3626                 .init_verbs = { alc880_volume_init_verbs,
3627                                 alc880_pin_3stack_init_verbs },
3628                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3629                 .dac_nids = alc880_dac_nids,
3630                 .dig_out_nid = ALC880_DIGOUT_NID,
3631                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3632                 .channel_mode = alc880_threestack_modes,
3633                 .need_dac_fix = 1,
3634                 .input_mux = &alc880_capture_source,
3635         },
3636         [ALC880_TCL_S700] = {
3637                 .mixers = { alc880_tcl_s700_mixer },
3638                 .init_verbs = { alc880_volume_init_verbs,
3639                                 alc880_pin_tcl_S700_init_verbs,
3640                                 alc880_gpio2_init_verbs },
3641                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3642                 .dac_nids = alc880_dac_nids,
3643                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3644                 .num_adc_nids = 1, /* single ADC */
3645                 .hp_nid = 0x03,
3646                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3647                 .channel_mode = alc880_2_jack_modes,
3648                 .input_mux = &alc880_capture_source,
3649         },
3650         [ALC880_5ST] = {
3651                 .mixers = { alc880_three_stack_mixer,
3652                             alc880_five_stack_mixer},
3653                 .init_verbs = { alc880_volume_init_verbs,
3654                                 alc880_pin_5stack_init_verbs },
3655                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3656                 .dac_nids = alc880_dac_nids,
3657                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3658                 .channel_mode = alc880_fivestack_modes,
3659                 .input_mux = &alc880_capture_source,
3660         },
3661         [ALC880_5ST_DIG] = {
3662                 .mixers = { alc880_three_stack_mixer,
3663                             alc880_five_stack_mixer },
3664                 .init_verbs = { alc880_volume_init_verbs,
3665                                 alc880_pin_5stack_init_verbs },
3666                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3667                 .dac_nids = alc880_dac_nids,
3668                 .dig_out_nid = ALC880_DIGOUT_NID,
3669                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3670                 .channel_mode = alc880_fivestack_modes,
3671                 .input_mux = &alc880_capture_source,
3672         },
3673         [ALC880_6ST] = {
3674                 .mixers = { alc880_six_stack_mixer },
3675                 .init_verbs = { alc880_volume_init_verbs,
3676                                 alc880_pin_6stack_init_verbs },
3677                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3678                 .dac_nids = alc880_6st_dac_nids,
3679                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3680                 .channel_mode = alc880_sixstack_modes,
3681                 .input_mux = &alc880_6stack_capture_source,
3682         },
3683         [ALC880_6ST_DIG] = {
3684                 .mixers = { alc880_six_stack_mixer },
3685                 .init_verbs = { alc880_volume_init_verbs,
3686                                 alc880_pin_6stack_init_verbs },
3687                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3688                 .dac_nids = alc880_6st_dac_nids,
3689                 .dig_out_nid = ALC880_DIGOUT_NID,
3690                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3691                 .channel_mode = alc880_sixstack_modes,
3692                 .input_mux = &alc880_6stack_capture_source,
3693         },
3694         [ALC880_W810] = {
3695                 .mixers = { alc880_w810_base_mixer },
3696                 .init_verbs = { alc880_volume_init_verbs,
3697                                 alc880_pin_w810_init_verbs,
3698                                 alc880_gpio2_init_verbs },
3699                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3700                 .dac_nids = alc880_w810_dac_nids,
3701                 .dig_out_nid = ALC880_DIGOUT_NID,
3702                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3703                 .channel_mode = alc880_w810_modes,
3704                 .input_mux = &alc880_capture_source,
3705         },
3706         [ALC880_Z71V] = {
3707                 .mixers = { alc880_z71v_mixer },
3708                 .init_verbs = { alc880_volume_init_verbs,
3709                                 alc880_pin_z71v_init_verbs },
3710                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3711                 .dac_nids = alc880_z71v_dac_nids,
3712                 .dig_out_nid = ALC880_DIGOUT_NID,
3713                 .hp_nid = 0x03,
3714                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3715                 .channel_mode = alc880_2_jack_modes,
3716                 .input_mux = &alc880_capture_source,
3717         },
3718         [ALC880_F1734] = {
3719                 .mixers = { alc880_f1734_mixer },
3720                 .init_verbs = { alc880_volume_init_verbs,
3721                                 alc880_pin_f1734_init_verbs },
3722                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3723                 .dac_nids = alc880_f1734_dac_nids,
3724                 .hp_nid = 0x02,
3725                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3726                 .channel_mode = alc880_2_jack_modes,
3727                 .input_mux = &alc880_f1734_capture_source,
3728                 .unsol_event = alc880_uniwill_p53_unsol_event,
3729                 .init_hook = alc880_uniwill_p53_hp_automute,
3730         },
3731         [ALC880_ASUS] = {
3732                 .mixers = { alc880_asus_mixer },
3733                 .init_verbs = { alc880_volume_init_verbs,
3734                                 alc880_pin_asus_init_verbs,
3735                                 alc880_gpio1_init_verbs },
3736                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3737                 .dac_nids = alc880_asus_dac_nids,
3738                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3739                 .channel_mode = alc880_asus_modes,
3740                 .need_dac_fix = 1,
3741                 .input_mux = &alc880_capture_source,
3742         },
3743         [ALC880_ASUS_DIG] = {
3744                 .mixers = { alc880_asus_mixer },
3745                 .init_verbs = { alc880_volume_init_verbs,
3746                                 alc880_pin_asus_init_verbs,
3747                                 alc880_gpio1_init_verbs },
3748                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3749                 .dac_nids = alc880_asus_dac_nids,
3750                 .dig_out_nid = ALC880_DIGOUT_NID,
3751                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3752                 .channel_mode = alc880_asus_modes,
3753                 .need_dac_fix = 1,
3754                 .input_mux = &alc880_capture_source,
3755         },
3756         [ALC880_ASUS_DIG2] = {
3757                 .mixers = { alc880_asus_mixer },
3758                 .init_verbs = { alc880_volume_init_verbs,
3759                                 alc880_pin_asus_init_verbs,
3760                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
3761                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3762                 .dac_nids = alc880_asus_dac_nids,
3763                 .dig_out_nid = ALC880_DIGOUT_NID,
3764                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3765                 .channel_mode = alc880_asus_modes,
3766                 .need_dac_fix = 1,
3767                 .input_mux = &alc880_capture_source,
3768         },
3769         [ALC880_ASUS_W1V] = {
3770                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
3771                 .init_verbs = { alc880_volume_init_verbs,
3772                                 alc880_pin_asus_init_verbs,
3773                                 alc880_gpio1_init_verbs },
3774                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3775                 .dac_nids = alc880_asus_dac_nids,
3776                 .dig_out_nid = ALC880_DIGOUT_NID,
3777                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3778                 .channel_mode = alc880_asus_modes,
3779                 .need_dac_fix = 1,
3780                 .input_mux = &alc880_capture_source,
3781         },
3782         [ALC880_UNIWILL_DIG] = {
3783                 .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
3784                 .init_verbs = { alc880_volume_init_verbs,
3785                                 alc880_pin_asus_init_verbs },
3786                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3787                 .dac_nids = alc880_asus_dac_nids,
3788                 .dig_out_nid = ALC880_DIGOUT_NID,
3789                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3790                 .channel_mode = alc880_asus_modes,
3791                 .need_dac_fix = 1,
3792                 .input_mux = &alc880_capture_source,
3793         },
3794         [ALC880_UNIWILL] = {
3795                 .mixers = { alc880_uniwill_mixer },
3796                 .init_verbs = { alc880_volume_init_verbs,
3797                                 alc880_uniwill_init_verbs },
3798                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3799                 .dac_nids = alc880_asus_dac_nids,
3800                 .dig_out_nid = ALC880_DIGOUT_NID,
3801                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3802                 .channel_mode = alc880_threestack_modes,
3803                 .need_dac_fix = 1,
3804                 .input_mux = &alc880_capture_source,
3805                 .unsol_event = alc880_uniwill_unsol_event,
3806                 .init_hook = alc880_uniwill_automute,
3807         },
3808         [ALC880_UNIWILL_P53] = {
3809                 .mixers = { alc880_uniwill_p53_mixer },
3810                 .init_verbs = { alc880_volume_init_verbs,
3811                                 alc880_uniwill_p53_init_verbs },
3812                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3813                 .dac_nids = alc880_asus_dac_nids,
3814                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3815                 .channel_mode = alc880_threestack_modes,
3816                 .input_mux = &alc880_capture_source,
3817                 .unsol_event = alc880_uniwill_p53_unsol_event,
3818                 .init_hook = alc880_uniwill_p53_hp_automute,
3819         },
3820         [ALC880_FUJITSU] = {
3821                 .mixers = { alc880_fujitsu_mixer,
3822                             alc880_pcbeep_mixer, },
3823                 .init_verbs = { alc880_volume_init_verbs,
3824                                 alc880_uniwill_p53_init_verbs,
3825                                 alc880_beep_init_verbs },
3826                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3827                 .dac_nids = alc880_dac_nids,
3828                 .dig_out_nid = ALC880_DIGOUT_NID,
3829                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3830                 .channel_mode = alc880_2_jack_modes,
3831                 .input_mux = &alc880_capture_source,
3832                 .unsol_event = alc880_uniwill_p53_unsol_event,
3833                 .init_hook = alc880_uniwill_p53_hp_automute,
3834         },
3835         [ALC880_CLEVO] = {
3836                 .mixers = { alc880_three_stack_mixer },
3837                 .init_verbs = { alc880_volume_init_verbs,
3838                                 alc880_pin_clevo_init_verbs },
3839                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3840                 .dac_nids = alc880_dac_nids,
3841                 .hp_nid = 0x03,
3842                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3843                 .channel_mode = alc880_threestack_modes,
3844                 .need_dac_fix = 1,
3845                 .input_mux = &alc880_capture_source,
3846         },
3847         [ALC880_LG] = {
3848                 .mixers = { alc880_lg_mixer },
3849                 .init_verbs = { alc880_volume_init_verbs,
3850                                 alc880_lg_init_verbs },
3851                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
3852                 .dac_nids = alc880_lg_dac_nids,
3853                 .dig_out_nid = ALC880_DIGOUT_NID,
3854                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
3855                 .channel_mode = alc880_lg_ch_modes,
3856                 .need_dac_fix = 1,
3857                 .input_mux = &alc880_lg_capture_source,
3858                 .unsol_event = alc880_lg_unsol_event,
3859                 .init_hook = alc880_lg_automute,
3860 #ifdef CONFIG_SND_HDA_POWER_SAVE
3861                 .loopbacks = alc880_lg_loopbacks,
3862 #endif
3863         },
3864         [ALC880_LG_LW] = {
3865                 .mixers = { alc880_lg_lw_mixer },
3866                 .init_verbs = { alc880_volume_init_verbs,
3867                                 alc880_lg_lw_init_verbs },
3868                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3869                 .dac_nids = alc880_dac_nids,
3870                 .dig_out_nid = ALC880_DIGOUT_NID,
3871                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
3872                 .channel_mode = alc880_lg_lw_modes,
3873                 .input_mux = &alc880_lg_lw_capture_source,
3874                 .unsol_event = alc880_lg_lw_unsol_event,
3875                 .init_hook = alc880_lg_lw_automute,
3876         },
3877         [ALC880_MEDION_RIM] = {
3878                 .mixers = { alc880_medion_rim_mixer },
3879                 .init_verbs = { alc880_volume_init_verbs,
3880                                 alc880_medion_rim_init_verbs,
3881                                 alc_gpio2_init_verbs },
3882                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3883                 .dac_nids = alc880_dac_nids,
3884                 .dig_out_nid = ALC880_DIGOUT_NID,
3885                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3886                 .channel_mode = alc880_2_jack_modes,
3887                 .input_mux = &alc880_medion_rim_capture_source,
3888                 .unsol_event = alc880_medion_rim_unsol_event,
3889                 .init_hook = alc880_medion_rim_automute,
3890         },
3891 #ifdef CONFIG_SND_DEBUG
3892         [ALC880_TEST] = {
3893                 .mixers = { alc880_test_mixer },
3894                 .init_verbs = { alc880_test_init_verbs },
3895                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
3896                 .dac_nids = alc880_test_dac_nids,
3897                 .dig_out_nid = ALC880_DIGOUT_NID,
3898                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
3899                 .channel_mode = alc880_test_modes,
3900                 .input_mux = &alc880_test_capture_source,
3901         },
3902 #endif
3903 };
3904
3905 /*
3906  * Automatic parse of I/O pins from the BIOS configuration
3907  */
3908
3909 enum {
3910         ALC_CTL_WIDGET_VOL,
3911         ALC_CTL_WIDGET_MUTE,
3912         ALC_CTL_BIND_MUTE,
3913 };
3914 static struct snd_kcontrol_new alc880_control_templates[] = {
3915         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
3916         HDA_CODEC_MUTE(NULL, 0, 0, 0),
3917         HDA_BIND_MUTE(NULL, 0, 0, 0),
3918 };
3919
3920 /* add dynamic controls */
3921 static int add_control(struct alc_spec *spec, int type, const char *name,
3922                        unsigned long val)
3923 {
3924         struct snd_kcontrol_new *knew;
3925
3926         snd_array_init(&spec->kctls, sizeof(*knew), 32);
3927         knew = snd_array_new(&spec->kctls);
3928         if (!knew)
3929                 return -ENOMEM;
3930         *knew = alc880_control_templates[type];
3931         knew->name = kstrdup(name, GFP_KERNEL);
3932         if (!knew->name)
3933                 return -ENOMEM;
3934         knew->private_value = val;
3935         return 0;
3936 }
3937
3938 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
3939 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
3940 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
3941 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
3942 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
3943 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
3944 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
3945 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
3946 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
3947 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
3948 #define ALC880_PIN_CD_NID               0x1c
3949
3950 /* fill in the dac_nids table from the parsed pin configuration */
3951 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
3952                                      const struct auto_pin_cfg *cfg)
3953 {
3954         hda_nid_t nid;
3955         int assigned[4];
3956         int i, j;
3957
3958         memset(assigned, 0, sizeof(assigned));
3959         spec->multiout.dac_nids = spec->private_dac_nids;
3960
3961         /* check the pins hardwired to audio widget */
3962         for (i = 0; i < cfg->line_outs; i++) {
3963                 nid = cfg->line_out_pins[i];
3964                 if (alc880_is_fixed_pin(nid)) {
3965                         int idx = alc880_fixed_pin_idx(nid);
3966                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
3967                         assigned[idx] = 1;
3968                 }
3969         }
3970         /* left pins can be connect to any audio widget */
3971         for (i = 0; i < cfg->line_outs; i++) {
3972                 nid = cfg->line_out_pins[i];
3973                 if (alc880_is_fixed_pin(nid))
3974                         continue;
3975                 /* search for an empty channel */
3976                 for (j = 0; j < cfg->line_outs; j++) {
3977                         if (!assigned[j]) {
3978                                 spec->multiout.dac_nids[i] =
3979                                         alc880_idx_to_dac(j);
3980                                 assigned[j] = 1;
3981                                 break;
3982                         }
3983                 }
3984         }
3985         spec->multiout.num_dacs = cfg->line_outs;
3986         return 0;
3987 }
3988
3989 /* add playback controls from the parsed DAC table */
3990 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
3991                                              const struct auto_pin_cfg *cfg)
3992 {
3993         char name[32];
3994         static const char *chname[4] = {
3995                 "Front", "Surround", NULL /*CLFE*/, "Side"
3996         };
3997         hda_nid_t nid;
3998         int i, err;
3999
4000         for (i = 0; i < cfg->line_outs; i++) {
4001                 if (!spec->multiout.dac_nids[i])
4002                         continue;
4003                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4004                 if (i == 2) {
4005                         /* Center/LFE */
4006                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4007                                           "Center Playback Volume",
4008                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4009                                                               HDA_OUTPUT));
4010                         if (err < 0)
4011                                 return err;
4012                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4013                                           "LFE Playback Volume",
4014                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4015                                                               HDA_OUTPUT));
4016                         if (err < 0)
4017                                 return err;
4018                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4019                                           "Center Playback Switch",
4020                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4021                                                               HDA_INPUT));
4022                         if (err < 0)
4023                                 return err;
4024                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4025                                           "LFE Playback Switch",
4026                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4027                                                               HDA_INPUT));
4028                         if (err < 0)
4029                                 return err;
4030                 } else {
4031                         sprintf(name, "%s Playback Volume", chname[i]);
4032                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4033                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4034                                                               HDA_OUTPUT));
4035                         if (err < 0)
4036                                 return err;
4037                         sprintf(name, "%s Playback Switch", chname[i]);
4038                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4039                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4040                                                               HDA_INPUT));
4041                         if (err < 0)
4042                                 return err;
4043                 }
4044         }
4045         return 0;
4046 }
4047
4048 /* add playback controls for speaker and HP outputs */
4049 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4050                                         const char *pfx)
4051 {
4052         hda_nid_t nid;
4053         int err;
4054         char name[32];
4055
4056         if (!pin)
4057                 return 0;
4058
4059         if (alc880_is_fixed_pin(pin)) {
4060                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4061                 /* specify the DAC as the extra output */
4062                 if (!spec->multiout.hp_nid)
4063                         spec->multiout.hp_nid = nid;
4064                 else
4065                         spec->multiout.extra_out_nid[0] = nid;
4066                 /* control HP volume/switch on the output mixer amp */
4067                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4068                 sprintf(name, "%s Playback Volume", pfx);
4069                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4070                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4071                 if (err < 0)
4072                         return err;
4073                 sprintf(name, "%s Playback Switch", pfx);
4074                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4075                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4076                 if (err < 0)
4077                         return err;
4078         } else if (alc880_is_multi_pin(pin)) {
4079                 /* set manual connection */
4080                 /* we have only a switch on HP-out PIN */
4081                 sprintf(name, "%s Playback Switch", pfx);
4082                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4083                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4084                 if (err < 0)
4085                         return err;
4086         }
4087         return 0;
4088 }
4089
4090 /* create input playback/capture controls for the given pin */
4091 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4092                             const char *ctlname,
4093                             int idx, hda_nid_t mix_nid)
4094 {
4095         char name[32];
4096         int err;
4097
4098         sprintf(name, "%s Playback Volume", ctlname);
4099         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4100                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4101         if (err < 0)
4102                 return err;
4103         sprintf(name, "%s Playback Switch", ctlname);
4104         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4105                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4106         if (err < 0)
4107                 return err;
4108         return 0;
4109 }
4110
4111 /* create playback/capture controls for input pins */
4112 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4113                                                 const struct auto_pin_cfg *cfg)
4114 {
4115         struct hda_input_mux *imux = &spec->private_imux;
4116         int i, err, idx;
4117
4118         for (i = 0; i < AUTO_PIN_LAST; i++) {
4119                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4120                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4121                         err = new_analog_input(spec, cfg->input_pins[i],
4122                                                auto_pin_cfg_labels[i],
4123                                                idx, 0x0b);
4124                         if (err < 0)
4125                                 return err;
4126                         imux->items[imux->num_items].label =
4127                                 auto_pin_cfg_labels[i];
4128                         imux->items[imux->num_items].index =
4129                                 alc880_input_pin_idx(cfg->input_pins[i]);
4130                         imux->num_items++;
4131                 }
4132         }
4133         return 0;
4134 }
4135
4136 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4137                                unsigned int pin_type)
4138 {
4139         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4140                             pin_type);
4141         /* unmute pin */
4142         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4143                             AMP_OUT_UNMUTE);
4144 }
4145
4146 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4147                                               hda_nid_t nid, int pin_type,
4148                                               int dac_idx)
4149 {
4150         alc_set_pin_output(codec, nid, pin_type);
4151         /* need the manual connection? */
4152         if (alc880_is_multi_pin(nid)) {
4153                 struct alc_spec *spec = codec->spec;
4154                 int idx = alc880_multi_pin_idx(nid);
4155                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4156                                     AC_VERB_SET_CONNECT_SEL,
4157                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4158         }
4159 }
4160
4161 static int get_pin_type(int line_out_type)
4162 {
4163         if (line_out_type == AUTO_PIN_HP_OUT)
4164                 return PIN_HP;
4165         else
4166                 return PIN_OUT;
4167 }
4168
4169 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4170 {
4171         struct alc_spec *spec = codec->spec;
4172         int i;
4173
4174         alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
4175         for (i = 0; i < spec->autocfg.line_outs; i++) {
4176                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4177                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4178                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4179         }
4180 }
4181
4182 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4183 {
4184         struct alc_spec *spec = codec->spec;
4185         hda_nid_t pin;
4186
4187         pin = spec->autocfg.speaker_pins[0];
4188         if (pin) /* connect to front */
4189                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4190         pin = spec->autocfg.hp_pins[0];
4191         if (pin) /* connect to front */
4192                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4193 }
4194
4195 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4196 {
4197         struct alc_spec *spec = codec->spec;
4198         int i;
4199
4200         for (i = 0; i < AUTO_PIN_LAST; i++) {
4201                 hda_nid_t nid = spec->autocfg.input_pins[i];
4202                 if (alc880_is_input_pin(nid)) {
4203                         snd_hda_codec_write(codec, nid, 0,
4204                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
4205                                             i <= AUTO_PIN_FRONT_MIC ?
4206                                             PIN_VREF80 : PIN_IN);
4207                         if (nid != ALC880_PIN_CD_NID)
4208                                 snd_hda_codec_write(codec, nid, 0,
4209                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4210                                                     AMP_OUT_MUTE);
4211                 }
4212         }
4213 }
4214
4215 /* parse the BIOS configuration and set up the alc_spec */
4216 /* return 1 if successful, 0 if the proper config is not found,
4217  * or a negative error code
4218  */
4219 static int alc880_parse_auto_config(struct hda_codec *codec)
4220 {
4221         struct alc_spec *spec = codec->spec;
4222         int err;
4223         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4224
4225         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4226                                            alc880_ignore);
4227         if (err < 0)
4228                 return err;
4229         if (!spec->autocfg.line_outs)
4230                 return 0; /* can't find valid BIOS pin config */
4231
4232         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4233         if (err < 0)
4234                 return err;
4235         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4236         if (err < 0)
4237                 return err;
4238         err = alc880_auto_create_extra_out(spec,
4239                                            spec->autocfg.speaker_pins[0],
4240                                            "Speaker");
4241         if (err < 0)
4242                 return err;
4243         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4244                                            "Headphone");
4245         if (err < 0)
4246                 return err;
4247         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4248         if (err < 0)
4249                 return err;
4250
4251         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4252
4253         if (spec->autocfg.dig_out_pin)
4254                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
4255         if (spec->autocfg.dig_in_pin)
4256                 spec->dig_in_nid = ALC880_DIGIN_NID;
4257
4258         if (spec->kctls.list)
4259                 add_mixer(spec, spec->kctls.list);
4260
4261         add_verb(spec, alc880_volume_init_verbs);
4262
4263         spec->num_mux_defs = 1;
4264         spec->input_mux = &spec->private_imux;
4265
4266         store_pin_configs(codec);
4267         return 1;
4268 }
4269
4270 /* additional initialization for auto-configuration model */
4271 static void alc880_auto_init(struct hda_codec *codec)
4272 {
4273         struct alc_spec *spec = codec->spec;
4274         alc880_auto_init_multi_out(codec);
4275         alc880_auto_init_extra_out(codec);
4276         alc880_auto_init_analog_input(codec);
4277         if (spec->unsol_event)
4278                 alc_inithook(codec);
4279 }
4280
4281 /*
4282  * OK, here we have finally the patch for ALC880
4283  */
4284
4285 static void set_capture_mixer(struct alc_spec *spec)
4286 {
4287         static struct snd_kcontrol_new *caps[3] = {
4288                 alc_capture_mixer1,
4289                 alc_capture_mixer2,
4290                 alc_capture_mixer3,
4291         };
4292         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3)
4293                 spec->cap_mixer = caps[spec->num_adc_nids - 1];
4294 }
4295
4296 static int patch_alc880(struct hda_codec *codec)
4297 {
4298         struct alc_spec *spec;
4299         int board_config;
4300         int err;
4301
4302         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4303         if (spec == NULL)
4304                 return -ENOMEM;
4305
4306         codec->spec = spec;
4307
4308         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4309                                                   alc880_models,
4310                                                   alc880_cfg_tbl);
4311         if (board_config < 0) {
4312                 printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
4313                        "trying auto-probe from BIOS...\n");
4314                 board_config = ALC880_AUTO;
4315         }
4316
4317         if (board_config == ALC880_AUTO) {
4318                 /* automatic parse from the BIOS config */
4319                 err = alc880_parse_auto_config(codec);
4320                 if (err < 0) {
4321                         alc_free(codec);
4322                         return err;
4323                 } else if (!err) {
4324                         printk(KERN_INFO
4325                                "hda_codec: Cannot set up configuration "
4326                                "from BIOS.  Using 3-stack mode...\n");
4327                         board_config = ALC880_3ST;
4328                 }
4329         }
4330
4331         if (board_config != ALC880_AUTO)
4332                 setup_preset(spec, &alc880_presets[board_config]);
4333
4334         spec->stream_name_analog = "ALC880 Analog";
4335         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4336         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4337         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4338
4339         spec->stream_name_digital = "ALC880 Digital";
4340         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4341         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4342
4343         if (!spec->adc_nids && spec->input_mux) {
4344                 /* check whether NID 0x07 is valid */
4345                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4346                 /* get type */
4347                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4348                 if (wcap != AC_WID_AUD_IN) {
4349                         spec->adc_nids = alc880_adc_nids_alt;
4350                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4351                 } else {
4352                         spec->adc_nids = alc880_adc_nids;
4353                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4354                 }
4355         }
4356         set_capture_mixer(spec);
4357
4358         spec->vmaster_nid = 0x0c;
4359
4360         codec->patch_ops = alc_patch_ops;
4361         if (board_config == ALC880_AUTO)
4362                 spec->init_hook = alc880_auto_init;
4363 #ifdef CONFIG_SND_HDA_POWER_SAVE
4364         if (!spec->loopback.amplist)
4365                 spec->loopback.amplist = alc880_loopbacks;
4366 #endif
4367         codec->proc_widget_hook = print_realtek_coef;
4368
4369         return 0;
4370 }
4371
4372
4373 /*
4374  * ALC260 support
4375  */
4376
4377 static hda_nid_t alc260_dac_nids[1] = {
4378         /* front */
4379         0x02,
4380 };
4381
4382 static hda_nid_t alc260_adc_nids[1] = {
4383         /* ADC0 */
4384         0x04,
4385 };
4386
4387 static hda_nid_t alc260_adc_nids_alt[1] = {
4388         /* ADC1 */
4389         0x05,
4390 };
4391
4392 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4393  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4394  */
4395 static hda_nid_t alc260_dual_adc_nids[2] = {
4396         /* ADC0, ADC1 */
4397         0x04, 0x05
4398 };
4399
4400 #define ALC260_DIGOUT_NID       0x03
4401 #define ALC260_DIGIN_NID        0x06
4402
4403 static struct hda_input_mux alc260_capture_source = {
4404         .num_items = 4,
4405         .items = {
4406                 { "Mic", 0x0 },
4407                 { "Front Mic", 0x1 },
4408                 { "Line", 0x2 },
4409                 { "CD", 0x4 },
4410         },
4411 };
4412
4413 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4414  * headphone jack and the internal CD lines since these are the only pins at
4415  * which audio can appear.  For flexibility, also allow the option of
4416  * recording the mixer output on the second ADC (ADC0 doesn't have a
4417  * connection to the mixer output).
4418  */
4419 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4420         {
4421                 .num_items = 3,
4422                 .items = {
4423                         { "Mic/Line", 0x0 },
4424                         { "CD", 0x4 },
4425                         { "Headphone", 0x2 },
4426                 },
4427         },
4428         {
4429                 .num_items = 4,
4430                 .items = {
4431                         { "Mic/Line", 0x0 },
4432                         { "CD", 0x4 },
4433                         { "Headphone", 0x2 },
4434                         { "Mixer", 0x5 },
4435                 },
4436         },
4437
4438 };
4439
4440 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4441  * the Fujitsu S702x, but jacks are marked differently.
4442  */
4443 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4444         {
4445                 .num_items = 4,
4446                 .items = {
4447                         { "Mic", 0x0 },
4448                         { "Line", 0x2 },
4449                         { "CD", 0x4 },
4450                         { "Headphone", 0x5 },
4451                 },
4452         },
4453         {
4454                 .num_items = 5,
4455                 .items = {
4456                         { "Mic", 0x0 },
4457                         { "Line", 0x2 },
4458                         { "CD", 0x4 },
4459                         { "Headphone", 0x6 },
4460                         { "Mixer", 0x5 },
4461                 },
4462         },
4463 };
4464 /*
4465  * This is just place-holder, so there's something for alc_build_pcms to look
4466  * at when it calculates the maximum number of channels. ALC260 has no mixer
4467  * element which allows changing the channel mode, so the verb list is
4468  * never used.
4469  */
4470 static struct hda_channel_mode alc260_modes[1] = {
4471         { 2, NULL },
4472 };
4473
4474
4475 /* Mixer combinations
4476  *
4477  * basic: base_output + input + pc_beep + capture
4478  * HP: base_output + input + capture_alt
4479  * HP_3013: hp_3013 + input + capture
4480  * fujitsu: fujitsu + capture
4481  * acer: acer + capture
4482  */
4483
4484 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4485         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4486         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4487         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4488         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4489         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4490         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4491         { } /* end */
4492 };
4493
4494 static struct snd_kcontrol_new alc260_input_mixer[] = {
4495         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4496         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4497         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4498         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4499         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4500         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4501         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4502         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4503         { } /* end */
4504 };
4505
4506 static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
4507         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
4508         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
4509         { } /* end */
4510 };
4511
4512 /* update HP, line and mono out pins according to the master switch */
4513 static void alc260_hp_master_update(struct hda_codec *codec,
4514                                     hda_nid_t hp, hda_nid_t line,
4515                                     hda_nid_t mono)
4516 {
4517         struct alc_spec *spec = codec->spec;
4518         unsigned int val = spec->master_sw ? PIN_HP : 0;
4519         /* change HP and line-out pins */
4520         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4521                             val);
4522         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4523                             val);
4524         /* mono (speaker) depending on the HP jack sense */
4525         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4526         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4527                             val);
4528 }
4529
4530 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4531                                    struct snd_ctl_elem_value *ucontrol)
4532 {
4533         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4534         struct alc_spec *spec = codec->spec;
4535         *ucontrol->value.integer.value = spec->master_sw;
4536         return 0;
4537 }
4538
4539 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4540                                    struct snd_ctl_elem_value *ucontrol)
4541 {
4542         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4543         struct alc_spec *spec = codec->spec;
4544         int val = !!*ucontrol->value.integer.value;
4545         hda_nid_t hp, line, mono;
4546
4547         if (val == spec->master_sw)
4548                 return 0;
4549         spec->master_sw = val;
4550         hp = (kcontrol->private_value >> 16) & 0xff;
4551         line = (kcontrol->private_value >> 8) & 0xff;
4552         mono = kcontrol->private_value & 0xff;
4553         alc260_hp_master_update(codec, hp, line, mono);
4554         return 1;
4555 }
4556
4557 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4558         {
4559                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4560                 .name = "Master Playback Switch",
4561                 .info = snd_ctl_boolean_mono_info,
4562                 .get = alc260_hp_master_sw_get,
4563                 .put = alc260_hp_master_sw_put,
4564                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4565         },
4566         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4567         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4568         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4569         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4570         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4571                               HDA_OUTPUT),
4572         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4573         { } /* end */
4574 };
4575
4576 static struct hda_verb alc260_hp_unsol_verbs[] = {
4577         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4578         {},
4579 };
4580
4581 static void alc260_hp_automute(struct hda_codec *codec)
4582 {
4583         struct alc_spec *spec = codec->spec;
4584         unsigned int present;
4585
4586         present = snd_hda_codec_read(codec, 0x10, 0,
4587                                      AC_VERB_GET_PIN_SENSE, 0);
4588         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4589         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4590 }
4591
4592 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4593 {
4594         if ((res >> 26) == ALC880_HP_EVENT)
4595                 alc260_hp_automute(codec);
4596 }
4597
4598 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4599         {
4600                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4601                 .name = "Master Playback Switch",
4602                 .info = snd_ctl_boolean_mono_info,
4603                 .get = alc260_hp_master_sw_get,
4604                 .put = alc260_hp_master_sw_put,
4605                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4606         },
4607         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4608         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4609         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4610         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4611         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4612         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4613         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4614         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4615         { } /* end */
4616 };
4617
4618 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4619         .ops = &snd_hda_bind_vol,
4620         .values = {
4621                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4622                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4623                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4624                 0
4625         },
4626 };
4627
4628 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4629         .ops = &snd_hda_bind_sw,
4630         .values = {
4631                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4632                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4633                 0
4634         },
4635 };
4636
4637 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4638         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4639         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4640         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4641         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4642         { } /* end */
4643 };
4644
4645 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4646         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4647         {},
4648 };
4649
4650 static void alc260_hp_3013_automute(struct hda_codec *codec)
4651 {
4652         struct alc_spec *spec = codec->spec;
4653         unsigned int present;
4654
4655         present = snd_hda_codec_read(codec, 0x15, 0,
4656                                      AC_VERB_GET_PIN_SENSE, 0);
4657         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4658         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4659 }
4660
4661 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4662                                        unsigned int res)
4663 {
4664         if ((res >> 26) == ALC880_HP_EVENT)
4665                 alc260_hp_3013_automute(codec);
4666 }
4667
4668 static void alc260_hp_3012_automute(struct hda_codec *codec)
4669 {
4670         unsigned int present, bits;
4671
4672         present = snd_hda_codec_read(codec, 0x10, 0,
4673                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4674
4675         bits = present ? 0 : PIN_OUT;
4676         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4677                             bits);
4678         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4679                             bits);
4680         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4681                             bits);
4682 }
4683
4684 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4685                                        unsigned int res)
4686 {
4687         if ((res >> 26) == ALC880_HP_EVENT)
4688                 alc260_hp_3012_automute(codec);
4689 }
4690
4691 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4692  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4693  */
4694 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4695         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4696         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4697         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4698         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4699         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4700         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4701         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4702         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4703         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4704         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4705         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4706         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4707         { } /* end */
4708 };
4709
4710 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4711  * versions of the ALC260 don't act on requests to enable mic bias from NID
4712  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
4713  * datasheet doesn't mention this restriction.  At this stage it's not clear
4714  * whether this behaviour is intentional or is a hardware bug in chip
4715  * revisions available in early 2006.  Therefore for now allow the
4716  * "Headphone Jack Mode" control to span all choices, but if it turns out
4717  * that the lack of mic bias for this NID is intentional we could change the
4718  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
4719  *
4720  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
4721  * don't appear to make the mic bias available from the "line" jack, even
4722  * though the NID used for this jack (0x14) can supply it.  The theory is
4723  * that perhaps Acer have included blocking capacitors between the ALC260
4724  * and the output jack.  If this turns out to be the case for all such
4725  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
4726  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
4727  *
4728  * The C20x Tablet series have a mono internal speaker which is controlled
4729  * via the chip's Mono sum widget and pin complex, so include the necessary
4730  * controls for such models.  On models without a "mono speaker" the control
4731  * won't do anything.
4732  */
4733 static struct snd_kcontrol_new alc260_acer_mixer[] = {
4734         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4735         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
4736         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
4737         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4738                               HDA_OUTPUT),
4739         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
4740                            HDA_INPUT),
4741         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4742         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4743         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4744         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4745         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4746         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4747         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4748         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4749         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4750         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4751         { } /* end */
4752 };
4753
4754 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
4755  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
4756  */
4757 static struct snd_kcontrol_new alc260_will_mixer[] = {
4758         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4759         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4761         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4762         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4763         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4764         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4765         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4766         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4767         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4768         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
4769         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
4770         { } /* end */
4771 };
4772
4773 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
4774  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
4775  */
4776 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
4777         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4778         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
4779         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4780         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4781         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
4782         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
4783         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
4784         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4785         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4786         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4787         { } /* end */
4788 };
4789
4790 /*
4791  * initialization verbs
4792  */
4793 static struct hda_verb alc260_init_verbs[] = {
4794         /* Line In pin widget for input */
4795         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4796         /* CD pin widget for input */
4797         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4798         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4799         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4800         /* Mic2 (front panel) pin widget for input and vref at 80% */
4801         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4802         /* LINE-2 is used for line-out in rear */
4803         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4804         /* select line-out */
4805         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
4806         /* LINE-OUT pin */
4807         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4808         /* enable HP */
4809         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4810         /* enable Mono */
4811         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4812         /* mute capture amp left and right */
4813         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4814         /* set connection select to line in (default select for this ADC) */
4815         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4816         /* mute capture amp left and right */
4817         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4818         /* set connection select to line in (default select for this ADC) */
4819         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
4820         /* set vol=0 Line-Out mixer amp left and right */
4821         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4822         /* unmute pin widget amp left and right (no gain on this amp) */
4823         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4824         /* set vol=0 HP mixer amp left and right */
4825         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4826         /* unmute pin widget amp left and right (no gain on this amp) */
4827         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4828         /* set vol=0 Mono mixer amp left and right */
4829         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4830         /* unmute pin widget amp left and right (no gain on this amp) */
4831         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4832         /* unmute LINE-2 out pin */
4833         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4834         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4835          * Line In 2 = 0x03
4836          */
4837         /* mute analog inputs */
4838         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4839         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4840         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4841         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4842         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4843         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4844         /* mute Front out path */
4845         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4846         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4847         /* mute Headphone out path */
4848         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4849         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4850         /* mute Mono out path */
4851         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4852         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4853         { }
4854 };
4855
4856 #if 0 /* should be identical with alc260_init_verbs? */
4857 static struct hda_verb alc260_hp_init_verbs[] = {
4858         /* Headphone and output */
4859         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4860         /* mono output */
4861         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4862         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4863         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4864         /* Mic2 (front panel) pin widget for input and vref at 80% */
4865         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4866         /* Line In pin widget for input */
4867         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4868         /* Line-2 pin widget for output */
4869         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4870         /* CD pin widget for input */
4871         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4872         /* unmute amp left and right */
4873         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4874         /* set connection select to line in (default select for this ADC) */
4875         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4876         /* unmute Line-Out mixer amp left and right (volume = 0) */
4877         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4878         /* mute pin widget amp left and right (no gain on this amp) */
4879         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4880         /* unmute HP mixer amp left and right (volume = 0) */
4881         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4882         /* mute pin widget amp left and right (no gain on this amp) */
4883         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4884         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4885          * Line In 2 = 0x03
4886          */
4887         /* mute analog inputs */
4888         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4889         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4890         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4891         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4892         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4893         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4894         /* Unmute Front out path */
4895         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4896         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4897         /* Unmute Headphone out path */
4898         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4899         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4900         /* Unmute Mono out path */
4901         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4902         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4903         { }
4904 };
4905 #endif
4906
4907 static struct hda_verb alc260_hp_3013_init_verbs[] = {
4908         /* Line out and output */
4909         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4910         /* mono output */
4911         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4912         /* Mic1 (rear panel) pin widget for input and vref at 80% */
4913         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4914         /* Mic2 (front panel) pin widget for input and vref at 80% */
4915         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
4916         /* Line In pin widget for input */
4917         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4918         /* Headphone pin widget for output */
4919         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
4920         /* CD pin widget for input */
4921         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
4922         /* unmute amp left and right */
4923         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
4924         /* set connection select to line in (default select for this ADC) */
4925         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
4926         /* unmute Line-Out mixer amp left and right (volume = 0) */
4927         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4928         /* mute pin widget amp left and right (no gain on this amp) */
4929         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4930         /* unmute HP mixer amp left and right (volume = 0) */
4931         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
4932         /* mute pin widget amp left and right (no gain on this amp) */
4933         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
4934         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
4935          * Line In 2 = 0x03
4936          */
4937         /* mute analog inputs */
4938         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4939         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4940         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4941         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4942         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4943         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
4944         /* Unmute Front out path */
4945         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4946         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4947         /* Unmute Headphone out path */
4948         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4949         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4950         /* Unmute Mono out path */
4951         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
4952         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
4953         { }
4954 };
4955
4956 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
4957  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
4958  * audio = 0x16, internal speaker = 0x10.
4959  */
4960 static struct hda_verb alc260_fujitsu_init_verbs[] = {
4961         /* Disable all GPIOs */
4962         {0x01, AC_VERB_SET_GPIO_MASK, 0},
4963         /* Internal speaker is connected to headphone pin */
4964         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
4965         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
4966         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4967         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
4968         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4969         /* Ensure all other unused pins are disabled and muted. */
4970         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4971         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4972         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4973         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4974         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4975         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4976         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
4977         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4978
4979         /* Disable digital (SPDIF) pins */
4980         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
4981         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
4982
4983         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
4984          * when acting as an output.
4985          */
4986         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
4987
4988         /* Start with output sum widgets muted and their output gains at min */
4989         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4990         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4991         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4992         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4993         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4994         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4995         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4996         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4997         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4998
4999         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5000         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5001         /* Unmute Line1 pin widget output buffer since it starts as an output.
5002          * If the pin mode is changed by the user the pin mode control will
5003          * take care of enabling the pin's input/output buffers as needed.
5004          * Therefore there's no need to enable the input buffer at this
5005          * stage.
5006          */
5007         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5008         /* Unmute input buffer of pin widget used for Line-in (no equiv
5009          * mixer ctrl)
5010          */
5011         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5012
5013         /* Mute capture amp left and right */
5014         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5015         /* Set ADC connection select to match default mixer setting - line
5016          * in (on mic1 pin)
5017          */
5018         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5019
5020         /* Do the same for the second ADC: mute capture input amp and
5021          * set ADC connection to line in (on mic1 pin)
5022          */
5023         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5024         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5025
5026         /* Mute all inputs to mixer widget (even unconnected ones) */
5027         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5028         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5029         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5030         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5031         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5032         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5033         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5034         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5035
5036         { }
5037 };
5038
5039 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5040  * similar laptops (adapted from Fujitsu init verbs).
5041  */
5042 static struct hda_verb alc260_acer_init_verbs[] = {
5043         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5044          * the headphone jack.  Turn this on and rely on the standard mute
5045          * methods whenever the user wants to turn these outputs off.
5046          */
5047         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5048         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5049         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5050         /* Internal speaker/Headphone jack is connected to Line-out pin */
5051         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5052         /* Internal microphone/Mic jack is connected to Mic1 pin */
5053         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5054         /* Line In jack is connected to Line1 pin */
5055         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5056         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5057         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5058         /* Ensure all other unused pins are disabled and muted. */
5059         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5060         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5061         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5062         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5063         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5064         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5065         /* Disable digital (SPDIF) pins */
5066         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5067         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5068
5069         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5070          * bus when acting as outputs.
5071          */
5072         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5073         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5074
5075         /* Start with output sum widgets muted and their output gains at min */
5076         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5077         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5078         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5079         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5080         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5081         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5082         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5083         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5084         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5085
5086         /* Unmute Line-out pin widget amp left and right
5087          * (no equiv mixer ctrl)
5088          */
5089         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5090         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5091         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5092         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5093          * inputs. If the pin mode is changed by the user the pin mode control
5094          * will take care of enabling the pin's input/output buffers as needed.
5095          * Therefore there's no need to enable the input buffer at this
5096          * stage.
5097          */
5098         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5099         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5100
5101         /* Mute capture amp left and right */
5102         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5103         /* Set ADC connection select to match default mixer setting - mic
5104          * (on mic1 pin)
5105          */
5106         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5107
5108         /* Do similar with the second ADC: mute capture input amp and
5109          * set ADC connection to mic to match ALSA's default state.
5110          */
5111         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5112         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5113
5114         /* Mute all inputs to mixer widget (even unconnected ones) */
5115         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5116         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5117         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5118         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5119         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5120         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5121         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5122         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5123
5124         { }
5125 };
5126
5127 static struct hda_verb alc260_will_verbs[] = {
5128         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5129         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5130         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5131         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5132         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5133         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5134         {}
5135 };
5136
5137 static struct hda_verb alc260_replacer_672v_verbs[] = {
5138         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5139         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5140         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5141
5142         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5143         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5144         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5145
5146         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5147         {}
5148 };
5149
5150 /* toggle speaker-output according to the hp-jack state */
5151 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5152 {
5153         unsigned int present;
5154
5155         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5156         present = snd_hda_codec_read(codec, 0x0f, 0,
5157                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5158         if (present) {
5159                 snd_hda_codec_write_cache(codec, 0x01, 0,
5160                                           AC_VERB_SET_GPIO_DATA, 1);
5161                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5162                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5163                                           PIN_HP);
5164         } else {
5165                 snd_hda_codec_write_cache(codec, 0x01, 0,
5166                                           AC_VERB_SET_GPIO_DATA, 0);
5167                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5168                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5169                                           PIN_OUT);
5170         }
5171 }
5172
5173 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5174                                        unsigned int res)
5175 {
5176         if ((res >> 26) == ALC880_HP_EVENT)
5177                 alc260_replacer_672v_automute(codec);
5178 }
5179
5180 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5181         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5182         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5183         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5184         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5185         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5186         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5187         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5188         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5189         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5190         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5191         {}
5192 };
5193
5194 /* Test configuration for debugging, modelled after the ALC880 test
5195  * configuration.
5196  */
5197 #ifdef CONFIG_SND_DEBUG
5198 static hda_nid_t alc260_test_dac_nids[1] = {
5199         0x02,
5200 };
5201 static hda_nid_t alc260_test_adc_nids[2] = {
5202         0x04, 0x05,
5203 };
5204 /* For testing the ALC260, each input MUX needs its own definition since
5205  * the signal assignments are different.  This assumes that the first ADC
5206  * is NID 0x04.
5207  */
5208 static struct hda_input_mux alc260_test_capture_sources[2] = {
5209         {
5210                 .num_items = 7,
5211                 .items = {
5212                         { "MIC1 pin", 0x0 },
5213                         { "MIC2 pin", 0x1 },
5214                         { "LINE1 pin", 0x2 },
5215                         { "LINE2 pin", 0x3 },
5216                         { "CD pin", 0x4 },
5217                         { "LINE-OUT pin", 0x5 },
5218                         { "HP-OUT pin", 0x6 },
5219                 },
5220         },
5221         {
5222                 .num_items = 8,
5223                 .items = {
5224                         { "MIC1 pin", 0x0 },
5225                         { "MIC2 pin", 0x1 },
5226                         { "LINE1 pin", 0x2 },
5227                         { "LINE2 pin", 0x3 },
5228                         { "CD pin", 0x4 },
5229                         { "Mixer", 0x5 },
5230                         { "LINE-OUT pin", 0x6 },
5231                         { "HP-OUT pin", 0x7 },
5232                 },
5233         },
5234 };
5235 static struct snd_kcontrol_new alc260_test_mixer[] = {
5236         /* Output driver widgets */
5237         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5238         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5239         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5240         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5241         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5242         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5243
5244         /* Modes for retasking pin widgets
5245          * Note: the ALC260 doesn't seem to act on requests to enable mic
5246          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5247          * mention this restriction.  At this stage it's not clear whether
5248          * this behaviour is intentional or is a hardware bug in chip
5249          * revisions available at least up until early 2006.  Therefore for
5250          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5251          * choices, but if it turns out that the lack of mic bias for these
5252          * NIDs is intentional we could change their modes from
5253          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5254          */
5255         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5256         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5257         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5258         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5259         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5260         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5261
5262         /* Loopback mixer controls */
5263         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5264         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5265         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5266         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5267         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5268         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5269         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5270         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5271         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5272         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5273         HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
5274         HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
5275         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5276         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5277         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5278         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5279
5280         /* Controls for GPIO pins, assuming they are configured as outputs */
5281         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5282         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5283         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5284         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5285
5286         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5287          * is ambigious as to which NID is which; testing on laptops which
5288          * make this output available should provide clarification.
5289          */
5290         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5291         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5292
5293         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5294          * this output to turn on an external amplifier.
5295          */
5296         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5297         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5298
5299         { } /* end */
5300 };
5301 static struct hda_verb alc260_test_init_verbs[] = {
5302         /* Enable all GPIOs as outputs with an initial value of 0 */
5303         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5304         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5305         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5306
5307         /* Enable retasking pins as output, initially without power amp */
5308         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5309         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5310         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5312         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5313         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5314
5315         /* Disable digital (SPDIF) pins initially, but users can enable
5316          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5317          * payload also sets the generation to 0, output to be in "consumer"
5318          * PCM format, copyright asserted, no pre-emphasis and no validity
5319          * control.
5320          */
5321         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5322         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5323
5324         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5325          * OUT1 sum bus when acting as an output.
5326          */
5327         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5328         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5329         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5330         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5331
5332         /* Start with output sum widgets muted and their output gains at min */
5333         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5334         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5335         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5336         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5337         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5338         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5339         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5340         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5341         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5342
5343         /* Unmute retasking pin widget output buffers since the default
5344          * state appears to be output.  As the pin mode is changed by the
5345          * user the pin mode control will take care of enabling the pin's
5346          * input/output buffers as needed.
5347          */
5348         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5349         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5350         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5351         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5352         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5353         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5354         /* Also unmute the mono-out pin widget */
5355         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5356
5357         /* Mute capture amp left and right */
5358         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5359         /* Set ADC connection select to match default mixer setting (mic1
5360          * pin)
5361          */
5362         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5363
5364         /* Do the same for the second ADC: mute capture input amp and
5365          * set ADC connection to mic1 pin
5366          */
5367         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5368         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5369
5370         /* Mute all inputs to mixer widget (even unconnected ones) */
5371         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5373         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5374         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5375         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5376         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5377         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5378         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5379
5380         { }
5381 };
5382 #endif
5383
5384 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5385 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5386
5387 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5388 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5389
5390 /*
5391  * for BIOS auto-configuration
5392  */
5393
5394 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5395                                         const char *pfx, int *vol_bits)
5396 {
5397         hda_nid_t nid_vol;
5398         unsigned long vol_val, sw_val;
5399         char name[32];
5400         int err;
5401
5402         if (nid >= 0x0f && nid < 0x11) {
5403                 nid_vol = nid - 0x7;
5404                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5405                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5406         } else if (nid == 0x11) {
5407                 nid_vol = nid - 0x7;
5408                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5409                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5410         } else if (nid >= 0x12 && nid <= 0x15) {
5411                 nid_vol = 0x08;
5412                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5413                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5414         } else
5415                 return 0; /* N/A */
5416
5417         if (!(*vol_bits & (1 << nid_vol))) {
5418                 /* first control for the volume widget */
5419                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5420                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5421                 if (err < 0)
5422                         return err;
5423                 *vol_bits |= (1 << nid_vol);
5424         }
5425         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5426         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5427         if (err < 0)
5428                 return err;
5429         return 1;
5430 }
5431
5432 /* add playback controls from the parsed DAC table */
5433 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5434                                              const struct auto_pin_cfg *cfg)
5435 {
5436         hda_nid_t nid;
5437         int err;
5438         int vols = 0;
5439
5440         spec->multiout.num_dacs = 1;
5441         spec->multiout.dac_nids = spec->private_dac_nids;
5442         spec->multiout.dac_nids[0] = 0x02;
5443
5444         nid = cfg->line_out_pins[0];
5445         if (nid) {
5446                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5447                 if (err < 0)
5448                         return err;
5449         }
5450
5451         nid = cfg->speaker_pins[0];
5452         if (nid) {
5453                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5454                 if (err < 0)
5455                         return err;
5456         }
5457
5458         nid = cfg->hp_pins[0];
5459         if (nid) {
5460                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5461                                                    &vols);
5462                 if (err < 0)
5463                         return err;
5464         }
5465         return 0;
5466 }
5467
5468 /* create playback/capture controls for input pins */
5469 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5470                                                 const struct auto_pin_cfg *cfg)
5471 {
5472         struct hda_input_mux *imux = &spec->private_imux;
5473         int i, err, idx;
5474
5475         for (i = 0; i < AUTO_PIN_LAST; i++) {
5476                 if (cfg->input_pins[i] >= 0x12) {
5477                         idx = cfg->input_pins[i] - 0x12;
5478                         err = new_analog_input(spec, cfg->input_pins[i],
5479                                                auto_pin_cfg_labels[i], idx,
5480                                                0x07);
5481                         if (err < 0)
5482                                 return err;
5483                         imux->items[imux->num_items].label =
5484                                 auto_pin_cfg_labels[i];
5485                         imux->items[imux->num_items].index = idx;
5486                         imux->num_items++;
5487                 }
5488                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5489                         idx = cfg->input_pins[i] - 0x09;
5490                         err = new_analog_input(spec, cfg->input_pins[i],
5491                                                auto_pin_cfg_labels[i], idx,
5492                                                0x07);
5493                         if (err < 0)
5494                                 return err;
5495                         imux->items[imux->num_items].label =
5496                                 auto_pin_cfg_labels[i];
5497                         imux->items[imux->num_items].index = idx;
5498                         imux->num_items++;
5499                 }
5500         }
5501         return 0;
5502 }
5503
5504 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5505                                               hda_nid_t nid, int pin_type,
5506                                               int sel_idx)
5507 {
5508         alc_set_pin_output(codec, nid, pin_type);
5509         /* need the manual connection? */
5510         if (nid >= 0x12) {
5511                 int idx = nid - 0x12;
5512                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5513                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5514         }
5515 }
5516
5517 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5518 {
5519         struct alc_spec *spec = codec->spec;
5520         hda_nid_t nid;
5521
5522         alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
5523         nid = spec->autocfg.line_out_pins[0];
5524         if (nid) {
5525                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5526                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5527         }
5528
5529         nid = spec->autocfg.speaker_pins[0];
5530         if (nid)
5531                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5532
5533         nid = spec->autocfg.hp_pins[0];
5534         if (nid)
5535                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5536 }
5537
5538 #define ALC260_PIN_CD_NID               0x16
5539 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5540 {
5541         struct alc_spec *spec = codec->spec;
5542         int i;
5543
5544         for (i = 0; i < AUTO_PIN_LAST; i++) {
5545                 hda_nid_t nid = spec->autocfg.input_pins[i];
5546                 if (nid >= 0x12) {
5547                         snd_hda_codec_write(codec, nid, 0,
5548                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
5549                                             i <= AUTO_PIN_FRONT_MIC ?
5550                                             PIN_VREF80 : PIN_IN);
5551                         if (nid != ALC260_PIN_CD_NID)
5552                                 snd_hda_codec_write(codec, nid, 0,
5553                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5554                                                     AMP_OUT_MUTE);
5555                 }
5556         }
5557 }
5558
5559 /*
5560  * generic initialization of ADC, input mixers and output mixers
5561  */
5562 static struct hda_verb alc260_volume_init_verbs[] = {
5563         /*
5564          * Unmute ADC0-1 and set the default input to mic-in
5565          */
5566         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5567         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5568         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5569         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5570
5571         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5572          * mixer widget
5573          * Note: PASD motherboards uses the Line In 2 as the input for
5574          * front panel mic (mic 2)
5575          */
5576         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5577         /* mute analog inputs */
5578         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5579         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5580         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5581         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5582         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5583
5584         /*
5585          * Set up output mixers (0x08 - 0x0a)
5586          */
5587         /* set vol=0 to output mixers */
5588         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5589         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5590         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5591         /* set up input amps for analog loopback */
5592         /* Amp Indices: DAC = 0, mixer = 1 */
5593         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5594         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5595         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5596         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5597         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5598         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5599
5600         { }
5601 };
5602
5603 static int alc260_parse_auto_config(struct hda_codec *codec)
5604 {
5605         struct alc_spec *spec = codec->spec;
5606         int err;
5607         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5608
5609         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5610                                            alc260_ignore);
5611         if (err < 0)
5612                 return err;
5613         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5614         if (err < 0)
5615                 return err;
5616         if (!spec->kctls.list)
5617                 return 0; /* can't find valid BIOS pin config */
5618         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5619         if (err < 0)
5620                 return err;
5621
5622         spec->multiout.max_channels = 2;
5623
5624         if (spec->autocfg.dig_out_pin)
5625                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
5626         if (spec->kctls.list)
5627                 add_mixer(spec, spec->kctls.list);
5628
5629         add_verb(spec, alc260_volume_init_verbs);
5630
5631         spec->num_mux_defs = 1;
5632         spec->input_mux = &spec->private_imux;
5633
5634         store_pin_configs(codec);
5635         return 1;
5636 }
5637
5638 /* additional initialization for auto-configuration model */
5639 static void alc260_auto_init(struct hda_codec *codec)
5640 {
5641         struct alc_spec *spec = codec->spec;
5642         alc260_auto_init_multi_out(codec);
5643         alc260_auto_init_analog_input(codec);
5644         if (spec->unsol_event)
5645                 alc_inithook(codec);
5646 }
5647
5648 #ifdef CONFIG_SND_HDA_POWER_SAVE
5649 static struct hda_amp_list alc260_loopbacks[] = {
5650         { 0x07, HDA_INPUT, 0 },
5651         { 0x07, HDA_INPUT, 1 },
5652         { 0x07, HDA_INPUT, 2 },
5653         { 0x07, HDA_INPUT, 3 },
5654         { 0x07, HDA_INPUT, 4 },
5655         { } /* end */
5656 };
5657 #endif
5658
5659 /*
5660  * ALC260 configurations
5661  */
5662 static const char *alc260_models[ALC260_MODEL_LAST] = {
5663         [ALC260_BASIC]          = "basic",
5664         [ALC260_HP]             = "hp",
5665         [ALC260_HP_3013]        = "hp-3013",
5666         [ALC260_HP_DC7600]      = "hp-dc7600",
5667         [ALC260_FUJITSU_S702X]  = "fujitsu",
5668         [ALC260_ACER]           = "acer",
5669         [ALC260_WILL]           = "will",
5670         [ALC260_REPLACER_672V]  = "replacer",
5671 #ifdef CONFIG_SND_DEBUG
5672         [ALC260_TEST]           = "test",
5673 #endif
5674         [ALC260_AUTO]           = "auto",
5675 };
5676
5677 static struct snd_pci_quirk alc260_cfg_tbl[] = {
5678         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
5679         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
5680         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
5681         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
5682         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
5683         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
5684         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
5685         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
5686         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
5687         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
5688         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
5689         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
5690         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
5691         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
5692         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
5693         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
5694         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
5695         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
5696         {}
5697 };
5698
5699 static struct alc_config_preset alc260_presets[] = {
5700         [ALC260_BASIC] = {
5701                 .mixers = { alc260_base_output_mixer,
5702                             alc260_input_mixer,
5703                             alc260_pc_beep_mixer },
5704                 .init_verbs = { alc260_init_verbs },
5705                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5706                 .dac_nids = alc260_dac_nids,
5707                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5708                 .adc_nids = alc260_adc_nids,
5709                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5710                 .channel_mode = alc260_modes,
5711                 .input_mux = &alc260_capture_source,
5712         },
5713         [ALC260_HP] = {
5714                 .mixers = { alc260_hp_output_mixer,
5715                             alc260_input_mixer },
5716                 .init_verbs = { alc260_init_verbs,
5717                                 alc260_hp_unsol_verbs },
5718                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5719                 .dac_nids = alc260_dac_nids,
5720                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5721                 .adc_nids = alc260_adc_nids_alt,
5722                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5723                 .channel_mode = alc260_modes,
5724                 .input_mux = &alc260_capture_source,
5725                 .unsol_event = alc260_hp_unsol_event,
5726                 .init_hook = alc260_hp_automute,
5727         },
5728         [ALC260_HP_DC7600] = {
5729                 .mixers = { alc260_hp_dc7600_mixer,
5730                             alc260_input_mixer },
5731                 .init_verbs = { alc260_init_verbs,
5732                                 alc260_hp_dc7600_verbs },
5733                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5734                 .dac_nids = alc260_dac_nids,
5735                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5736                 .adc_nids = alc260_adc_nids_alt,
5737                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5738                 .channel_mode = alc260_modes,
5739                 .input_mux = &alc260_capture_source,
5740                 .unsol_event = alc260_hp_3012_unsol_event,
5741                 .init_hook = alc260_hp_3012_automute,
5742         },
5743         [ALC260_HP_3013] = {
5744                 .mixers = { alc260_hp_3013_mixer,
5745                             alc260_input_mixer },
5746                 .init_verbs = { alc260_hp_3013_init_verbs,
5747                                 alc260_hp_3013_unsol_verbs },
5748                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5749                 .dac_nids = alc260_dac_nids,
5750                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
5751                 .adc_nids = alc260_adc_nids_alt,
5752                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5753                 .channel_mode = alc260_modes,
5754                 .input_mux = &alc260_capture_source,
5755                 .unsol_event = alc260_hp_3013_unsol_event,
5756                 .init_hook = alc260_hp_3013_automute,
5757         },
5758         [ALC260_FUJITSU_S702X] = {
5759                 .mixers = { alc260_fujitsu_mixer },
5760                 .init_verbs = { alc260_fujitsu_init_verbs },
5761                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5762                 .dac_nids = alc260_dac_nids,
5763                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5764                 .adc_nids = alc260_dual_adc_nids,
5765                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5766                 .channel_mode = alc260_modes,
5767                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
5768                 .input_mux = alc260_fujitsu_capture_sources,
5769         },
5770         [ALC260_ACER] = {
5771                 .mixers = { alc260_acer_mixer },
5772                 .init_verbs = { alc260_acer_init_verbs },
5773                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5774                 .dac_nids = alc260_dac_nids,
5775                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
5776                 .adc_nids = alc260_dual_adc_nids,
5777                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5778                 .channel_mode = alc260_modes,
5779                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
5780                 .input_mux = alc260_acer_capture_sources,
5781         },
5782         [ALC260_WILL] = {
5783                 .mixers = { alc260_will_mixer },
5784                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
5785                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5786                 .dac_nids = alc260_dac_nids,
5787                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5788                 .adc_nids = alc260_adc_nids,
5789                 .dig_out_nid = ALC260_DIGOUT_NID,
5790                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5791                 .channel_mode = alc260_modes,
5792                 .input_mux = &alc260_capture_source,
5793         },
5794         [ALC260_REPLACER_672V] = {
5795                 .mixers = { alc260_replacer_672v_mixer },
5796                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
5797                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
5798                 .dac_nids = alc260_dac_nids,
5799                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
5800                 .adc_nids = alc260_adc_nids,
5801                 .dig_out_nid = ALC260_DIGOUT_NID,
5802                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5803                 .channel_mode = alc260_modes,
5804                 .input_mux = &alc260_capture_source,
5805                 .unsol_event = alc260_replacer_672v_unsol_event,
5806                 .init_hook = alc260_replacer_672v_automute,
5807         },
5808 #ifdef CONFIG_SND_DEBUG
5809         [ALC260_TEST] = {
5810                 .mixers = { alc260_test_mixer },
5811                 .init_verbs = { alc260_test_init_verbs },
5812                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
5813                 .dac_nids = alc260_test_dac_nids,
5814                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
5815                 .adc_nids = alc260_test_adc_nids,
5816                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
5817                 .channel_mode = alc260_modes,
5818                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
5819                 .input_mux = alc260_test_capture_sources,
5820         },
5821 #endif
5822 };
5823
5824 static int patch_alc260(struct hda_codec *codec)
5825 {
5826         struct alc_spec *spec;
5827         int err, board_config;
5828
5829         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5830         if (spec == NULL)
5831                 return -ENOMEM;
5832
5833         codec->spec = spec;
5834
5835         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
5836                                                   alc260_models,
5837                                                   alc260_cfg_tbl);
5838         if (board_config < 0) {
5839                 snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
5840                            "trying auto-probe from BIOS...\n");
5841                 board_config = ALC260_AUTO;
5842         }
5843
5844         if (board_config == ALC260_AUTO) {
5845                 /* automatic parse from the BIOS config */
5846                 err = alc260_parse_auto_config(codec);
5847                 if (err < 0) {
5848                         alc_free(codec);
5849                         return err;
5850                 } else if (!err) {
5851                         printk(KERN_INFO
5852                                "hda_codec: Cannot set up configuration "
5853                                "from BIOS.  Using base mode...\n");
5854                         board_config = ALC260_BASIC;
5855                 }
5856         }
5857
5858         if (board_config != ALC260_AUTO)
5859                 setup_preset(spec, &alc260_presets[board_config]);
5860
5861         spec->stream_name_analog = "ALC260 Analog";
5862         spec->stream_analog_playback = &alc260_pcm_analog_playback;
5863         spec->stream_analog_capture = &alc260_pcm_analog_capture;
5864
5865         spec->stream_name_digital = "ALC260 Digital";
5866         spec->stream_digital_playback = &alc260_pcm_digital_playback;
5867         spec->stream_digital_capture = &alc260_pcm_digital_capture;
5868
5869         if (!spec->adc_nids && spec->input_mux) {
5870                 /* check whether NID 0x04 is valid */
5871                 unsigned int wcap = get_wcaps(codec, 0x04);
5872                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
5873                 /* get type */
5874                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
5875                         spec->adc_nids = alc260_adc_nids_alt;
5876                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
5877                 } else {
5878                         spec->adc_nids = alc260_adc_nids;
5879                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
5880                 }
5881         }
5882         set_capture_mixer(spec);
5883
5884         spec->vmaster_nid = 0x08;
5885
5886         codec->patch_ops = alc_patch_ops;
5887         if (board_config == ALC260_AUTO)
5888                 spec->init_hook = alc260_auto_init;
5889 #ifdef CONFIG_SND_HDA_POWER_SAVE
5890         if (!spec->loopback.amplist)
5891                 spec->loopback.amplist = alc260_loopbacks;
5892 #endif
5893         codec->proc_widget_hook = print_realtek_coef;
5894
5895         return 0;
5896 }
5897
5898
5899 /*
5900  * ALC882 support
5901  *
5902  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
5903  * configuration.  Each pin widget can choose any input DACs and a mixer.
5904  * Each ADC is connected from a mixer of all inputs.  This makes possible
5905  * 6-channel independent captures.
5906  *
5907  * In addition, an independent DAC for the multi-playback (not used in this
5908  * driver yet).
5909  */
5910 #define ALC882_DIGOUT_NID       0x06
5911 #define ALC882_DIGIN_NID        0x0a
5912
5913 static struct hda_channel_mode alc882_ch_modes[1] = {
5914         { 8, NULL }
5915 };
5916
5917 static hda_nid_t alc882_dac_nids[4] = {
5918         /* front, rear, clfe, rear_surr */
5919         0x02, 0x03, 0x04, 0x05
5920 };
5921
5922 /* identical with ALC880 */
5923 #define alc882_adc_nids         alc880_adc_nids
5924 #define alc882_adc_nids_alt     alc880_adc_nids_alt
5925
5926 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
5927 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
5928
5929 /* input MUX */
5930 /* FIXME: should be a matrix-type input source selection */
5931
5932 static struct hda_input_mux alc882_capture_source = {
5933         .num_items = 4,
5934         .items = {
5935            &n