ALSA: hda - Add snd_hda_multi_out_dig_cleanup()
[linux-2.6.git] / sound / pci / hda / patch_analog.c
1 /*
2  * HD audio interface patch for AD1882, AD1884, AD1981HD, AD1983, AD1984,
3  *   AD1986A, AD1988
4  *
5  * Copyright (c) 2005-2007 Takashi Iwai <tiwai@suse.de>
6  *
7  *  This driver is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2 of the License, or
10  *  (at your option) any later version.
11  *
12  *  This driver is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20  */
21
22 #include <linux/init.h>
23 #include <linux/delay.h>
24 #include <linux/slab.h>
25 #include <linux/pci.h>
26
27 #include <sound/core.h>
28 #include "hda_codec.h"
29 #include "hda_local.h"
30
31 struct ad198x_spec {
32         struct snd_kcontrol_new *mixers[5];
33         int num_mixers;
34
35         const struct hda_verb *init_verbs[5];   /* initialization verbs
36                                                  * don't forget NULL termination!
37                                                  */
38         unsigned int num_init_verbs;
39
40         /* playback */
41         struct hda_multi_out multiout;  /* playback set-up
42                                          * max_channels, dacs must be set
43                                          * dig_out_nid and hp_nid are optional
44                                          */
45         unsigned int cur_eapd;
46         unsigned int need_dac_fix;
47
48         /* capture */
49         unsigned int num_adc_nids;
50         hda_nid_t *adc_nids;
51         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
52
53         /* capture source */
54         const struct hda_input_mux *input_mux;
55         hda_nid_t *capsrc_nids;
56         unsigned int cur_mux[3];
57
58         /* channel model */
59         const struct hda_channel_mode *channel_mode;
60         int num_channel_mode;
61
62         /* PCM information */
63         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
64
65         unsigned int spdif_route;
66
67         /* dynamic controls, init_verbs and input_mux */
68         struct auto_pin_cfg autocfg;
69         struct snd_array kctls;
70         struct hda_input_mux private_imux;
71         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
72
73         unsigned int jack_present :1;
74
75 #ifdef CONFIG_SND_HDA_POWER_SAVE
76         struct hda_loopback_check loopback;
77 #endif
78         /* for virtual master */
79         hda_nid_t vmaster_nid;
80         const char **slave_vols;
81         const char **slave_sws;
82 };
83
84 /*
85  * input MUX handling (common part)
86  */
87 static int ad198x_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
88 {
89         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
90         struct ad198x_spec *spec = codec->spec;
91
92         return snd_hda_input_mux_info(spec->input_mux, uinfo);
93 }
94
95 static int ad198x_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
96 {
97         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
98         struct ad198x_spec *spec = codec->spec;
99         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
100
101         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
102         return 0;
103 }
104
105 static int ad198x_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
106 {
107         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
108         struct ad198x_spec *spec = codec->spec;
109         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
110
111         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
112                                      spec->capsrc_nids[adc_idx],
113                                      &spec->cur_mux[adc_idx]);
114 }
115
116 /*
117  * initialization (common callbacks)
118  */
119 static int ad198x_init(struct hda_codec *codec)
120 {
121         struct ad198x_spec *spec = codec->spec;
122         int i;
123
124         for (i = 0; i < spec->num_init_verbs; i++)
125                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
126         return 0;
127 }
128
129 static const char *ad_slave_vols[] = {
130         "Front Playback Volume",
131         "Surround Playback Volume",
132         "Center Playback Volume",
133         "LFE Playback Volume",
134         "Side Playback Volume",
135         "Headphone Playback Volume",
136         "Mono Playback Volume",
137         "Speaker Playback Volume",
138         "IEC958 Playback Volume",
139         NULL
140 };
141
142 static const char *ad_slave_sws[] = {
143         "Front Playback Switch",
144         "Surround Playback Switch",
145         "Center Playback Switch",
146         "LFE Playback Switch",
147         "Side Playback Switch",
148         "Headphone Playback Switch",
149         "Mono Playback Switch",
150         "Speaker Playback Switch",
151         "IEC958 Playback Switch",
152         NULL
153 };
154
155 static void ad198x_free_kctls(struct hda_codec *codec);
156
157 static int ad198x_build_controls(struct hda_codec *codec)
158 {
159         struct ad198x_spec *spec = codec->spec;
160         unsigned int i;
161         int err;
162
163         for (i = 0; i < spec->num_mixers; i++) {
164                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
165                 if (err < 0)
166                         return err;
167         }
168         if (spec->multiout.dig_out_nid) {
169                 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
170                 if (err < 0)
171                         return err;
172                 err = snd_hda_create_spdif_share_sw(codec,
173                                                     &spec->multiout);
174                 if (err < 0)
175                         return err;
176                 spec->multiout.share_spdif = 1;
177         } 
178         if (spec->dig_in_nid) {
179                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
180                 if (err < 0)
181                         return err;
182         }
183
184         /* if we have no master control, let's create it */
185         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
186                 unsigned int vmaster_tlv[4];
187                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
188                                         HDA_OUTPUT, vmaster_tlv);
189                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
190                                           vmaster_tlv,
191                                           (spec->slave_vols ?
192                                            spec->slave_vols : ad_slave_vols));
193                 if (err < 0)
194                         return err;
195         }
196         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
197                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
198                                           NULL,
199                                           (spec->slave_sws ?
200                                            spec->slave_sws : ad_slave_sws));
201                 if (err < 0)
202                         return err;
203         }
204
205         ad198x_free_kctls(codec); /* no longer needed */
206         return 0;
207 }
208
209 #ifdef CONFIG_SND_HDA_POWER_SAVE
210 static int ad198x_check_power_status(struct hda_codec *codec, hda_nid_t nid)
211 {
212         struct ad198x_spec *spec = codec->spec;
213         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
214 }
215 #endif
216
217 /*
218  * Analog playback callbacks
219  */
220 static int ad198x_playback_pcm_open(struct hda_pcm_stream *hinfo,
221                                     struct hda_codec *codec,
222                                     struct snd_pcm_substream *substream)
223 {
224         struct ad198x_spec *spec = codec->spec;
225         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
226                                              hinfo);
227 }
228
229 static int ad198x_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
230                                        struct hda_codec *codec,
231                                        unsigned int stream_tag,
232                                        unsigned int format,
233                                        struct snd_pcm_substream *substream)
234 {
235         struct ad198x_spec *spec = codec->spec;
236         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
237                                                 format, substream);
238 }
239
240 static int ad198x_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
241                                        struct hda_codec *codec,
242                                        struct snd_pcm_substream *substream)
243 {
244         struct ad198x_spec *spec = codec->spec;
245         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
246 }
247
248 /*
249  * Digital out
250  */
251 static int ad198x_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
252                                         struct hda_codec *codec,
253                                         struct snd_pcm_substream *substream)
254 {
255         struct ad198x_spec *spec = codec->spec;
256         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
257 }
258
259 static int ad198x_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
260                                          struct hda_codec *codec,
261                                          struct snd_pcm_substream *substream)
262 {
263         struct ad198x_spec *spec = codec->spec;
264         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
265 }
266
267 static int ad198x_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
268                                            struct hda_codec *codec,
269                                            unsigned int stream_tag,
270                                            unsigned int format,
271                                            struct snd_pcm_substream *substream)
272 {
273         struct ad198x_spec *spec = codec->spec;
274         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
275                                              format, substream);
276 }
277
278 static int ad198x_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
279                                            struct hda_codec *codec,
280                                            struct snd_pcm_substream *substream)
281 {
282         struct ad198x_spec *spec = codec->spec;
283         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
284 }
285
286 /*
287  * Analog capture
288  */
289 static int ad198x_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
290                                       struct hda_codec *codec,
291                                       unsigned int stream_tag,
292                                       unsigned int format,
293                                       struct snd_pcm_substream *substream)
294 {
295         struct ad198x_spec *spec = codec->spec;
296         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
297                                    stream_tag, 0, format);
298         return 0;
299 }
300
301 static int ad198x_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
302                                       struct hda_codec *codec,
303                                       struct snd_pcm_substream *substream)
304 {
305         struct ad198x_spec *spec = codec->spec;
306         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
307         return 0;
308 }
309
310
311 /*
312  */
313 static struct hda_pcm_stream ad198x_pcm_analog_playback = {
314         .substreams = 1,
315         .channels_min = 2,
316         .channels_max = 6, /* changed later */
317         .nid = 0, /* fill later */
318         .ops = {
319                 .open = ad198x_playback_pcm_open,
320                 .prepare = ad198x_playback_pcm_prepare,
321                 .cleanup = ad198x_playback_pcm_cleanup
322         },
323 };
324
325 static struct hda_pcm_stream ad198x_pcm_analog_capture = {
326         .substreams = 1,
327         .channels_min = 2,
328         .channels_max = 2,
329         .nid = 0, /* fill later */
330         .ops = {
331                 .prepare = ad198x_capture_pcm_prepare,
332                 .cleanup = ad198x_capture_pcm_cleanup
333         },
334 };
335
336 static struct hda_pcm_stream ad198x_pcm_digital_playback = {
337         .substreams = 1,
338         .channels_min = 2,
339         .channels_max = 2,
340         .nid = 0, /* fill later */
341         .ops = {
342                 .open = ad198x_dig_playback_pcm_open,
343                 .close = ad198x_dig_playback_pcm_close,
344                 .prepare = ad198x_dig_playback_pcm_prepare,
345                 .cleanup = ad198x_dig_playback_pcm_cleanup
346         },
347 };
348
349 static struct hda_pcm_stream ad198x_pcm_digital_capture = {
350         .substreams = 1,
351         .channels_min = 2,
352         .channels_max = 2,
353         /* NID is set in alc_build_pcms */
354 };
355
356 static int ad198x_build_pcms(struct hda_codec *codec)
357 {
358         struct ad198x_spec *spec = codec->spec;
359         struct hda_pcm *info = spec->pcm_rec;
360
361         codec->num_pcms = 1;
362         codec->pcm_info = info;
363
364         info->name = "AD198x Analog";
365         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_analog_playback;
366         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->multiout.max_channels;
367         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
368         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_analog_capture;
369         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adc_nids;
370         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
371
372         if (spec->multiout.dig_out_nid) {
373                 info++;
374                 codec->num_pcms++;
375                 info->name = "AD198x Digital";
376                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
377                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ad198x_pcm_digital_playback;
378                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
379                 if (spec->dig_in_nid) {
380                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = ad198x_pcm_digital_capture;
381                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
382                 }
383         }
384
385         return 0;
386 }
387
388 static void ad198x_free_kctls(struct hda_codec *codec)
389 {
390         struct ad198x_spec *spec = codec->spec;
391
392         if (spec->kctls.list) {
393                 struct snd_kcontrol_new *kctl = spec->kctls.list;
394                 int i;
395                 for (i = 0; i < spec->kctls.used; i++)
396                         kfree(kctl[i].name);
397         }
398         snd_array_free(&spec->kctls);
399 }
400
401 static void ad198x_free(struct hda_codec *codec)
402 {
403         struct ad198x_spec *spec = codec->spec;
404
405         if (!spec)
406                 return;
407
408         ad198x_free_kctls(codec);
409         kfree(codec->spec);
410 }
411
412 static struct hda_codec_ops ad198x_patch_ops = {
413         .build_controls = ad198x_build_controls,
414         .build_pcms = ad198x_build_pcms,
415         .init = ad198x_init,
416         .free = ad198x_free,
417 #ifdef CONFIG_SND_HDA_POWER_SAVE
418         .check_power_status = ad198x_check_power_status,
419 #endif
420 };
421
422
423 /*
424  * EAPD control
425  * the private value = nid | (invert << 8)
426  */
427 #define ad198x_eapd_info        snd_ctl_boolean_mono_info
428
429 static int ad198x_eapd_get(struct snd_kcontrol *kcontrol,
430                            struct snd_ctl_elem_value *ucontrol)
431 {
432         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
433         struct ad198x_spec *spec = codec->spec;
434         int invert = (kcontrol->private_value >> 8) & 1;
435         if (invert)
436                 ucontrol->value.integer.value[0] = ! spec->cur_eapd;
437         else
438                 ucontrol->value.integer.value[0] = spec->cur_eapd;
439         return 0;
440 }
441
442 static int ad198x_eapd_put(struct snd_kcontrol *kcontrol,
443                            struct snd_ctl_elem_value *ucontrol)
444 {
445         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
446         struct ad198x_spec *spec = codec->spec;
447         int invert = (kcontrol->private_value >> 8) & 1;
448         hda_nid_t nid = kcontrol->private_value & 0xff;
449         unsigned int eapd;
450         eapd = !!ucontrol->value.integer.value[0];
451         if (invert)
452                 eapd = !eapd;
453         if (eapd == spec->cur_eapd)
454                 return 0;
455         spec->cur_eapd = eapd;
456         snd_hda_codec_write_cache(codec, nid,
457                                   0, AC_VERB_SET_EAPD_BTLENABLE,
458                                   eapd ? 0x02 : 0x00);
459         return 1;
460 }
461
462 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
463                                struct snd_ctl_elem_info *uinfo);
464 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
465                               struct snd_ctl_elem_value *ucontrol);
466 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
467                               struct snd_ctl_elem_value *ucontrol);
468
469
470 /*
471  * AD1986A specific
472  */
473
474 #define AD1986A_SPDIF_OUT       0x02
475 #define AD1986A_FRONT_DAC       0x03
476 #define AD1986A_SURR_DAC        0x04
477 #define AD1986A_CLFE_DAC        0x05
478 #define AD1986A_ADC             0x06
479
480 static hda_nid_t ad1986a_dac_nids[3] = {
481         AD1986A_FRONT_DAC, AD1986A_SURR_DAC, AD1986A_CLFE_DAC
482 };
483 static hda_nid_t ad1986a_adc_nids[1] = { AD1986A_ADC };
484 static hda_nid_t ad1986a_capsrc_nids[1] = { 0x12 };
485
486 static struct hda_input_mux ad1986a_capture_source = {
487         .num_items = 7,
488         .items = {
489                 { "Mic", 0x0 },
490                 { "CD", 0x1 },
491                 { "Aux", 0x3 },
492                 { "Line", 0x4 },
493                 { "Mix", 0x5 },
494                 { "Mono", 0x6 },
495                 { "Phone", 0x7 },
496         },
497 };
498
499
500 static struct hda_bind_ctls ad1986a_bind_pcm_vol = {
501         .ops = &snd_hda_bind_vol,
502         .values = {
503                 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
504                 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
505                 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
506                 0
507         },
508 };
509
510 static struct hda_bind_ctls ad1986a_bind_pcm_sw = {
511         .ops = &snd_hda_bind_sw,
512         .values = {
513                 HDA_COMPOSE_AMP_VAL(AD1986A_FRONT_DAC, 3, 0, HDA_OUTPUT),
514                 HDA_COMPOSE_AMP_VAL(AD1986A_SURR_DAC, 3, 0, HDA_OUTPUT),
515                 HDA_COMPOSE_AMP_VAL(AD1986A_CLFE_DAC, 3, 0, HDA_OUTPUT),
516                 0
517         },
518 };
519
520 /*
521  * mixers
522  */
523 static struct snd_kcontrol_new ad1986a_mixers[] = {
524         /*
525          * bind volumes/mutes of 3 DACs as a single PCM control for simplicity
526          */
527         HDA_BIND_VOL("PCM Playback Volume", &ad1986a_bind_pcm_vol),
528         HDA_BIND_SW("PCM Playback Switch", &ad1986a_bind_pcm_sw),
529         HDA_CODEC_VOLUME("Front Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
530         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
531         HDA_CODEC_VOLUME("Surround Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
532         HDA_CODEC_MUTE("Surround Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
533         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x1d, 1, 0x0, HDA_OUTPUT),
534         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x1d, 2, 0x0, HDA_OUTPUT),
535         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x1d, 1, 0x0, HDA_OUTPUT),
536         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x1d, 2, 0x0, HDA_OUTPUT),
537         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x1a, 0x0, HDA_OUTPUT),
538         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
539         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
540         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
541         HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
542         HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
543         HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
544         HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
545         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
546         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
547         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
548         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
549         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
550         HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
551         HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
552         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
553         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
554         {
555                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
556                 .name = "Capture Source",
557                 .info = ad198x_mux_enum_info,
558                 .get = ad198x_mux_enum_get,
559                 .put = ad198x_mux_enum_put,
560         },
561         HDA_CODEC_MUTE("Stereo Downmix Switch", 0x09, 0x0, HDA_OUTPUT),
562         { } /* end */
563 };
564
565 /* additional mixers for 3stack mode */
566 static struct snd_kcontrol_new ad1986a_3st_mixers[] = {
567         {
568                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
569                 .name = "Channel Mode",
570                 .info = ad198x_ch_mode_info,
571                 .get = ad198x_ch_mode_get,
572                 .put = ad198x_ch_mode_put,
573         },
574         { } /* end */
575 };
576
577 /* laptop model - 2ch only */
578 static hda_nid_t ad1986a_laptop_dac_nids[1] = { AD1986A_FRONT_DAC };
579
580 /* master controls both pins 0x1a and 0x1b */
581 static struct hda_bind_ctls ad1986a_laptop_master_vol = {
582         .ops = &snd_hda_bind_vol,
583         .values = {
584                 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
585                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
586                 0,
587         },
588 };
589
590 static struct hda_bind_ctls ad1986a_laptop_master_sw = {
591         .ops = &snd_hda_bind_sw,
592         .values = {
593                 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
594                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
595                 0,
596         },
597 };
598
599 static struct snd_kcontrol_new ad1986a_laptop_mixers[] = {
600         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
601         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
602         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
603         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
604         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_OUTPUT),
605         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_OUTPUT),
606         HDA_CODEC_VOLUME("Line Playback Volume", 0x17, 0x0, HDA_OUTPUT),
607         HDA_CODEC_MUTE("Line Playback Switch", 0x17, 0x0, HDA_OUTPUT),
608         HDA_CODEC_VOLUME("Aux Playback Volume", 0x16, 0x0, HDA_OUTPUT),
609         HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
610         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
611         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
612         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
613         /* HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x18, 0x0, HDA_OUTPUT),
614            HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x18, 0x0, HDA_OUTPUT),
615            HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
616            HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
617         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
618         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
619         {
620                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
621                 .name = "Capture Source",
622                 .info = ad198x_mux_enum_info,
623                 .get = ad198x_mux_enum_get,
624                 .put = ad198x_mux_enum_put,
625         },
626         { } /* end */
627 };
628
629 /* laptop-eapd model - 2ch only */
630
631 static struct hda_input_mux ad1986a_laptop_eapd_capture_source = {
632         .num_items = 3,
633         .items = {
634                 { "Mic", 0x0 },
635                 { "Internal Mic", 0x4 },
636                 { "Mix", 0x5 },
637         },
638 };
639
640 static struct hda_input_mux ad1986a_automic_capture_source = {
641         .num_items = 2,
642         .items = {
643                 { "Mic", 0x0 },
644                 { "Mix", 0x5 },
645         },
646 };
647
648 static struct snd_kcontrol_new ad1986a_laptop_eapd_mixers[] = {
649         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
650         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
651         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
652         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
653         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0, HDA_OUTPUT),
654         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0, HDA_OUTPUT),
655         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
656         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
657         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
658         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
659         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
660         {
661                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
662                 .name = "Capture Source",
663                 .info = ad198x_mux_enum_info,
664                 .get = ad198x_mux_enum_get,
665                 .put = ad198x_mux_enum_put,
666         },
667         {
668                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
669                 .name = "External Amplifier",
670                 .info = ad198x_eapd_info,
671                 .get = ad198x_eapd_get,
672                 .put = ad198x_eapd_put,
673                 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
674         },
675         { } /* end */
676 };
677
678 static struct snd_kcontrol_new ad1986a_samsung_mixers[] = {
679         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
680         HDA_BIND_SW("Master Playback Switch", &ad1986a_laptop_master_sw),
681         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
682         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
683         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
684         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
685         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
686         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
687         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
688         {
689                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
690                 .name = "Capture Source",
691                 .info = ad198x_mux_enum_info,
692                 .get = ad198x_mux_enum_get,
693                 .put = ad198x_mux_enum_put,
694         },
695         {
696                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
697                 .name = "External Amplifier",
698                 .info = ad198x_eapd_info,
699                 .get = ad198x_eapd_get,
700                 .put = ad198x_eapd_put,
701                 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
702         },
703         { } /* end */
704 };
705
706 /* re-connect the mic boost input according to the jack sensing */
707 static void ad1986a_automic(struct hda_codec *codec)
708 {
709         unsigned int present;
710         present = snd_hda_codec_read(codec, 0x1f, 0, AC_VERB_GET_PIN_SENSE, 0);
711         /* 0 = 0x1f, 2 = 0x1d, 4 = mixed */
712         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_CONNECT_SEL,
713                             (present & AC_PINSENSE_PRESENCE) ? 0 : 2);
714 }
715
716 #define AD1986A_MIC_EVENT               0x36
717
718 static void ad1986a_automic_unsol_event(struct hda_codec *codec,
719                                             unsigned int res)
720 {
721         if ((res >> 26) != AD1986A_MIC_EVENT)
722                 return;
723         ad1986a_automic(codec);
724 }
725
726 static int ad1986a_automic_init(struct hda_codec *codec)
727 {
728         ad198x_init(codec);
729         ad1986a_automic(codec);
730         return 0;
731 }
732
733 /* laptop-automute - 2ch only */
734
735 static void ad1986a_update_hp(struct hda_codec *codec)
736 {
737         struct ad198x_spec *spec = codec->spec;
738         unsigned int mute;
739
740         if (spec->jack_present)
741                 mute = HDA_AMP_MUTE; /* mute internal speaker */
742         else
743                 /* unmute internal speaker if necessary */
744                 mute = snd_hda_codec_amp_read(codec, 0x1a, 0, HDA_OUTPUT, 0);
745         snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
746                                  HDA_AMP_MUTE, mute);
747 }
748
749 static void ad1986a_hp_automute(struct hda_codec *codec)
750 {
751         struct ad198x_spec *spec = codec->spec;
752         unsigned int present;
753
754         present = snd_hda_codec_read(codec, 0x1a, 0, AC_VERB_GET_PIN_SENSE, 0);
755         /* Lenovo N100 seems to report the reversed bit for HP jack-sensing */
756         spec->jack_present = !(present & 0x80000000);
757         ad1986a_update_hp(codec);
758 }
759
760 #define AD1986A_HP_EVENT                0x37
761
762 static void ad1986a_hp_unsol_event(struct hda_codec *codec, unsigned int res)
763 {
764         if ((res >> 26) != AD1986A_HP_EVENT)
765                 return;
766         ad1986a_hp_automute(codec);
767 }
768
769 static int ad1986a_hp_init(struct hda_codec *codec)
770 {
771         ad198x_init(codec);
772         ad1986a_hp_automute(codec);
773         return 0;
774 }
775
776 /* bind hp and internal speaker mute (with plug check) */
777 static int ad1986a_hp_master_sw_put(struct snd_kcontrol *kcontrol,
778                                     struct snd_ctl_elem_value *ucontrol)
779 {
780         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
781         long *valp = ucontrol->value.integer.value;
782         int change;
783
784         change = snd_hda_codec_amp_update(codec, 0x1a, 0, HDA_OUTPUT, 0,
785                                           HDA_AMP_MUTE,
786                                           valp[0] ? 0 : HDA_AMP_MUTE);
787         change |= snd_hda_codec_amp_update(codec, 0x1a, 1, HDA_OUTPUT, 0,
788                                            HDA_AMP_MUTE,
789                                            valp[1] ? 0 : HDA_AMP_MUTE);
790         if (change)
791                 ad1986a_update_hp(codec);
792         return change;
793 }
794
795 static struct snd_kcontrol_new ad1986a_laptop_automute_mixers[] = {
796         HDA_BIND_VOL("Master Playback Volume", &ad1986a_laptop_master_vol),
797         {
798                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
799                 .name = "Master Playback Switch",
800                 .info = snd_hda_mixer_amp_switch_info,
801                 .get = snd_hda_mixer_amp_switch_get,
802                 .put = ad1986a_hp_master_sw_put,
803                 .private_value = HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_OUTPUT),
804         },
805         HDA_CODEC_VOLUME("PCM Playback Volume", 0x03, 0x0, HDA_OUTPUT),
806         HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
807         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x17, 0x0, HDA_OUTPUT),
808         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x17, 0x0, HDA_OUTPUT),
809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
810         HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
811         HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
812         HDA_CODEC_VOLUME("Beep Playback Volume", 0x18, 0x0, HDA_OUTPUT),
813         HDA_CODEC_MUTE("Beep Playback Switch", 0x18, 0x0, HDA_OUTPUT),
814         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
815         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
816         {
817                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
818                 .name = "Capture Source",
819                 .info = ad198x_mux_enum_info,
820                 .get = ad198x_mux_enum_get,
821                 .put = ad198x_mux_enum_put,
822         },
823         {
824                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
825                 .name = "External Amplifier",
826                 .info = ad198x_eapd_info,
827                 .get = ad198x_eapd_get,
828                 .put = ad198x_eapd_put,
829                 .private_value = 0x1b | (1 << 8), /* port-D, inversed */
830         },
831         { } /* end */
832 };
833
834 /*
835  * initialization verbs
836  */
837 static struct hda_verb ad1986a_init_verbs[] = {
838         /* Front, Surround, CLFE DAC; mute as default */
839         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
840         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
841         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
842         /* Downmix - off */
843         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
844         /* HP, Line-Out, Surround, CLFE selectors */
845         {0x0a, AC_VERB_SET_CONNECT_SEL, 0x0},
846         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0},
847         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
848         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
849         /* Mono selector */
850         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x0},
851         /* Mic selector: Mic 1/2 pin */
852         {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
853         /* Line-in selector: Line-in */
854         {0x10, AC_VERB_SET_CONNECT_SEL, 0x0},
855         /* Mic 1/2 swap */
856         {0x11, AC_VERB_SET_CONNECT_SEL, 0x0},
857         /* Record selector: mic */
858         {0x12, AC_VERB_SET_CONNECT_SEL, 0x0},
859         /* Mic, Phone, CD, Aux, Line-In amp; mute as default */
860         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
861         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
862         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
863         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
864         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
865         /* PC beep */
866         {0x18, AC_VERB_SET_CONNECT_SEL, 0x0},
867         /* HP, Line-Out, Surround, CLFE, Mono pins; mute as default */
868         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
869         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
870         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
871         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
872         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
873         /* HP Pin */
874         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
875         /* Front, Surround, CLFE Pins */
876         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
877         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
878         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
879         /* Mono Pin */
880         {0x1e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
881         /* Mic Pin */
882         {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
883         /* Line, Aux, CD, Beep-In Pin */
884         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
885         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
886         {0x22, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
887         {0x23, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
888         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
889         { } /* end */
890 };
891
892 static struct hda_verb ad1986a_ch2_init[] = {
893         /* Surround out -> Line In */
894         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
895         /* Line-in selectors */
896         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x1 },
897         /* CLFE -> Mic in */
898         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
899         /* Mic selector, mix C/LFE (backmic) and Mic (frontmic) */
900         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
901         { } /* end */
902 };
903
904 static struct hda_verb ad1986a_ch4_init[] = {
905         /* Surround out -> Surround */
906         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
907         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
908         /* CLFE -> Mic in */
909         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
910         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x4 },
911         { } /* end */
912 };
913
914 static struct hda_verb ad1986a_ch6_init[] = {
915         /* Surround out -> Surround out */
916         { 0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
917         { 0x10, AC_VERB_SET_CONNECT_SEL, 0x0 },
918         /* CLFE -> CLFE */
919         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
920         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x0 },
921         { } /* end */
922 };
923
924 static struct hda_channel_mode ad1986a_modes[3] = {
925         { 2, ad1986a_ch2_init },
926         { 4, ad1986a_ch4_init },
927         { 6, ad1986a_ch6_init },
928 };
929
930 /* eapd initialization */
931 static struct hda_verb ad1986a_eapd_init_verbs[] = {
932         {0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
933         {}
934 };
935
936 static struct hda_verb ad1986a_automic_verbs[] = {
937         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
938         {0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
939         /*{0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},*/
940         {0x0f, AC_VERB_SET_CONNECT_SEL, 0x0},
941         {0x1f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_MIC_EVENT},
942         {}
943 };
944
945 /* Ultra initialization */
946 static struct hda_verb ad1986a_ultra_init[] = {
947         /* eapd initialization */
948         { 0x1b, AC_VERB_SET_EAPD_BTLENABLE, 0x00 },
949         /* CLFE -> Mic in */
950         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2 },
951         { 0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
952         { 0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
953         { } /* end */
954 };
955
956 /* pin sensing on HP jack */
957 static struct hda_verb ad1986a_hp_init_verbs[] = {
958         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1986A_HP_EVENT},
959         {}
960 };
961
962
963 /* models */
964 enum {
965         AD1986A_6STACK,
966         AD1986A_3STACK,
967         AD1986A_LAPTOP,
968         AD1986A_LAPTOP_EAPD,
969         AD1986A_LAPTOP_AUTOMUTE,
970         AD1986A_ULTRA,
971         AD1986A_SAMSUNG,
972         AD1986A_MODELS
973 };
974
975 static const char *ad1986a_models[AD1986A_MODELS] = {
976         [AD1986A_6STACK]        = "6stack",
977         [AD1986A_3STACK]        = "3stack",
978         [AD1986A_LAPTOP]        = "laptop",
979         [AD1986A_LAPTOP_EAPD]   = "laptop-eapd",
980         [AD1986A_LAPTOP_AUTOMUTE] = "laptop-automute",
981         [AD1986A_ULTRA]         = "ultra",
982         [AD1986A_SAMSUNG]       = "samsung",
983 };
984
985 static struct snd_pci_quirk ad1986a_cfg_tbl[] = {
986         SND_PCI_QUIRK(0x103c, 0x30af, "HP B2800", AD1986A_LAPTOP_EAPD),
987         SND_PCI_QUIRK(0x1043, 0x1153, "ASUS M9", AD1986A_LAPTOP_EAPD),
988         SND_PCI_QUIRK(0x1043, 0x11f7, "ASUS U5A", AD1986A_LAPTOP_EAPD),
989         SND_PCI_QUIRK(0x1043, 0x1213, "ASUS A6J", AD1986A_LAPTOP_EAPD),
990         SND_PCI_QUIRK(0x1043, 0x1263, "ASUS U5F", AD1986A_LAPTOP_EAPD),
991         SND_PCI_QUIRK(0x1043, 0x1297, "ASUS Z62F", AD1986A_LAPTOP_EAPD),
992         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS V1j", AD1986A_LAPTOP_EAPD),
993         SND_PCI_QUIRK(0x1043, 0x1302, "ASUS W3j", AD1986A_LAPTOP_EAPD),
994         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS VX1", AD1986A_LAPTOP),
995         SND_PCI_QUIRK(0x1043, 0x1447, "ASUS A8J", AD1986A_3STACK),
996         SND_PCI_QUIRK(0x1043, 0x817f, "ASUS P5", AD1986A_3STACK),
997         SND_PCI_QUIRK(0x1043, 0x818f, "ASUS P5", AD1986A_LAPTOP),
998         SND_PCI_QUIRK(0x1043, 0x81b3, "ASUS P5", AD1986A_3STACK),
999         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS M2N", AD1986A_3STACK),
1000         SND_PCI_QUIRK(0x1043, 0x8234, "ASUS M2N", AD1986A_3STACK),
1001         SND_PCI_QUIRK(0x10de, 0xcb84, "ASUS A8N-VM", AD1986A_3STACK),
1002         SND_PCI_QUIRK(0x1179, 0xff40, "Toshiba", AD1986A_LAPTOP_EAPD),
1003         SND_PCI_QUIRK(0x144d, 0xb03c, "Samsung R55", AD1986A_3STACK),
1004         SND_PCI_QUIRK(0x144d, 0xc01e, "FSC V2060", AD1986A_LAPTOP),
1005         SND_PCI_QUIRK(0x144d, 0xc023, "Samsung X60", AD1986A_SAMSUNG),
1006         SND_PCI_QUIRK(0x144d, 0xc024, "Samsung R65", AD1986A_SAMSUNG),
1007         SND_PCI_QUIRK(0x144d, 0xc026, "Samsung X11", AD1986A_SAMSUNG),
1008         SND_PCI_QUIRK(0x144d, 0xc027, "Samsung Q1", AD1986A_ULTRA),
1009         SND_PCI_QUIRK(0x144d, 0xc504, "Samsung Q35", AD1986A_3STACK),
1010         SND_PCI_QUIRK(0x17aa, 0x1011, "Lenovo M55", AD1986A_LAPTOP),
1011         SND_PCI_QUIRK(0x17aa, 0x1017, "Lenovo A60", AD1986A_3STACK),
1012         SND_PCI_QUIRK(0x17aa, 0x2066, "Lenovo N100", AD1986A_LAPTOP_AUTOMUTE),
1013         SND_PCI_QUIRK(0x17c0, 0x2017, "Samsung M50", AD1986A_LAPTOP),
1014         {}
1015 };
1016
1017 #ifdef CONFIG_SND_HDA_POWER_SAVE
1018 static struct hda_amp_list ad1986a_loopbacks[] = {
1019         { 0x13, HDA_OUTPUT, 0 }, /* Mic */
1020         { 0x14, HDA_OUTPUT, 0 }, /* Phone */
1021         { 0x15, HDA_OUTPUT, 0 }, /* CD */
1022         { 0x16, HDA_OUTPUT, 0 }, /* Aux */
1023         { 0x17, HDA_OUTPUT, 0 }, /* Line */
1024         { } /* end */
1025 };
1026 #endif
1027
1028 static int is_jack_available(struct hda_codec *codec, hda_nid_t nid)
1029 {
1030         unsigned int conf = snd_hda_codec_read(codec, nid, 0,
1031                                                AC_VERB_GET_CONFIG_DEFAULT, 0);
1032         return get_defcfg_connect(conf) != AC_JACK_PORT_NONE;
1033 }
1034
1035 static int patch_ad1986a(struct hda_codec *codec)
1036 {
1037         struct ad198x_spec *spec;
1038         int board_config;
1039
1040         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1041         if (spec == NULL)
1042                 return -ENOMEM;
1043
1044         codec->spec = spec;
1045
1046         spec->multiout.max_channels = 6;
1047         spec->multiout.num_dacs = ARRAY_SIZE(ad1986a_dac_nids);
1048         spec->multiout.dac_nids = ad1986a_dac_nids;
1049         spec->multiout.dig_out_nid = AD1986A_SPDIF_OUT;
1050         spec->num_adc_nids = 1;
1051         spec->adc_nids = ad1986a_adc_nids;
1052         spec->capsrc_nids = ad1986a_capsrc_nids;
1053         spec->input_mux = &ad1986a_capture_source;
1054         spec->num_mixers = 1;
1055         spec->mixers[0] = ad1986a_mixers;
1056         spec->num_init_verbs = 1;
1057         spec->init_verbs[0] = ad1986a_init_verbs;
1058 #ifdef CONFIG_SND_HDA_POWER_SAVE
1059         spec->loopback.amplist = ad1986a_loopbacks;
1060 #endif
1061         spec->vmaster_nid = 0x1b;
1062
1063         codec->patch_ops = ad198x_patch_ops;
1064
1065         /* override some parameters */
1066         board_config = snd_hda_check_board_config(codec, AD1986A_MODELS,
1067                                                   ad1986a_models,
1068                                                   ad1986a_cfg_tbl);
1069         switch (board_config) {
1070         case AD1986A_3STACK:
1071                 spec->num_mixers = 2;
1072                 spec->mixers[1] = ad1986a_3st_mixers;
1073                 spec->num_init_verbs = 2;
1074                 spec->init_verbs[1] = ad1986a_ch2_init;
1075                 spec->channel_mode = ad1986a_modes;
1076                 spec->num_channel_mode = ARRAY_SIZE(ad1986a_modes);
1077                 spec->need_dac_fix = 1;
1078                 spec->multiout.max_channels = 2;
1079                 spec->multiout.num_dacs = 1;
1080                 break;
1081         case AD1986A_LAPTOP:
1082                 spec->mixers[0] = ad1986a_laptop_mixers;
1083                 spec->multiout.max_channels = 2;
1084                 spec->multiout.num_dacs = 1;
1085                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1086                 break;
1087         case AD1986A_LAPTOP_EAPD:
1088                 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1089                 spec->num_init_verbs = 2;
1090                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1091                 spec->multiout.max_channels = 2;
1092                 spec->multiout.num_dacs = 1;
1093                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1094                 if (!is_jack_available(codec, 0x25))
1095                         spec->multiout.dig_out_nid = 0;
1096                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1097                 break;
1098         case AD1986A_SAMSUNG:
1099                 spec->mixers[0] = ad1986a_samsung_mixers;
1100                 spec->num_init_verbs = 3;
1101                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1102                 spec->init_verbs[2] = ad1986a_automic_verbs;
1103                 spec->multiout.max_channels = 2;
1104                 spec->multiout.num_dacs = 1;
1105                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1106                 if (!is_jack_available(codec, 0x25))
1107                         spec->multiout.dig_out_nid = 0;
1108                 spec->input_mux = &ad1986a_automic_capture_source;
1109                 codec->patch_ops.unsol_event = ad1986a_automic_unsol_event;
1110                 codec->patch_ops.init = ad1986a_automic_init;
1111                 break;
1112         case AD1986A_LAPTOP_AUTOMUTE:
1113                 spec->mixers[0] = ad1986a_laptop_automute_mixers;
1114                 spec->num_init_verbs = 3;
1115                 spec->init_verbs[1] = ad1986a_eapd_init_verbs;
1116                 spec->init_verbs[2] = ad1986a_hp_init_verbs;
1117                 spec->multiout.max_channels = 2;
1118                 spec->multiout.num_dacs = 1;
1119                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1120                 if (!is_jack_available(codec, 0x25))
1121                         spec->multiout.dig_out_nid = 0;
1122                 spec->input_mux = &ad1986a_laptop_eapd_capture_source;
1123                 codec->patch_ops.unsol_event = ad1986a_hp_unsol_event;
1124                 codec->patch_ops.init = ad1986a_hp_init;
1125                 break;
1126         case AD1986A_ULTRA:
1127                 spec->mixers[0] = ad1986a_laptop_eapd_mixers;
1128                 spec->num_init_verbs = 2;
1129                 spec->init_verbs[1] = ad1986a_ultra_init;
1130                 spec->multiout.max_channels = 2;
1131                 spec->multiout.num_dacs = 1;
1132                 spec->multiout.dac_nids = ad1986a_laptop_dac_nids;
1133                 spec->multiout.dig_out_nid = 0;
1134                 break;
1135         }
1136
1137         /* AD1986A has a hardware problem that it can't share a stream
1138          * with multiple output pins.  The copy of front to surrounds
1139          * causes noisy or silent outputs at a certain timing, e.g.
1140          * changing the volume.
1141          * So, let's disable the shared stream.
1142          */
1143         spec->multiout.no_share_stream = 1;
1144
1145         return 0;
1146 }
1147
1148 /*
1149  * AD1983 specific
1150  */
1151
1152 #define AD1983_SPDIF_OUT        0x02
1153 #define AD1983_DAC              0x03
1154 #define AD1983_ADC              0x04
1155
1156 static hda_nid_t ad1983_dac_nids[1] = { AD1983_DAC };
1157 static hda_nid_t ad1983_adc_nids[1] = { AD1983_ADC };
1158 static hda_nid_t ad1983_capsrc_nids[1] = { 0x15 };
1159
1160 static struct hda_input_mux ad1983_capture_source = {
1161         .num_items = 4,
1162         .items = {
1163                 { "Mic", 0x0 },
1164                 { "Line", 0x1 },
1165                 { "Mix", 0x2 },
1166                 { "Mix Mono", 0x3 },
1167         },
1168 };
1169
1170 /*
1171  * SPDIF playback route
1172  */
1173 static int ad1983_spdif_route_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1174 {
1175         static char *texts[] = { "PCM", "ADC" };
1176
1177         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1178         uinfo->count = 1;
1179         uinfo->value.enumerated.items = 2;
1180         if (uinfo->value.enumerated.item > 1)
1181                 uinfo->value.enumerated.item = 1;
1182         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
1183         return 0;
1184 }
1185
1186 static int ad1983_spdif_route_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1187 {
1188         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1189         struct ad198x_spec *spec = codec->spec;
1190
1191         ucontrol->value.enumerated.item[0] = spec->spdif_route;
1192         return 0;
1193 }
1194
1195 static int ad1983_spdif_route_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1196 {
1197         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1198         struct ad198x_spec *spec = codec->spec;
1199
1200         if (ucontrol->value.enumerated.item[0] > 1)
1201                 return -EINVAL;
1202         if (spec->spdif_route != ucontrol->value.enumerated.item[0]) {
1203                 spec->spdif_route = ucontrol->value.enumerated.item[0];
1204                 snd_hda_codec_write_cache(codec, spec->multiout.dig_out_nid, 0,
1205                                           AC_VERB_SET_CONNECT_SEL,
1206                                           spec->spdif_route);
1207                 return 1;
1208         }
1209         return 0;
1210 }
1211
1212 static struct snd_kcontrol_new ad1983_mixers[] = {
1213         HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1214         HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1215         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1216         HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1217         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1218         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1219         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1220         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1221         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1222         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1223         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1224         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1225         HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x10, 1, 0x0, HDA_OUTPUT),
1226         HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x10, 1, 0x0, HDA_OUTPUT),
1227         HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
1228         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1229         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1230         {
1231                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1232                 .name = "Capture Source",
1233                 .info = ad198x_mux_enum_info,
1234                 .get = ad198x_mux_enum_get,
1235                 .put = ad198x_mux_enum_put,
1236         },
1237         {
1238                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1239                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1240                 .info = ad1983_spdif_route_info,
1241                 .get = ad1983_spdif_route_get,
1242                 .put = ad1983_spdif_route_put,
1243         },
1244         { } /* end */
1245 };
1246
1247 static struct hda_verb ad1983_init_verbs[] = {
1248         /* Front, HP, Mono; mute as default */
1249         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1250         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1251         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1252         /* Beep, PCM, Mic, Line-In: mute */
1253         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1254         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1255         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1256         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1257         /* Front, HP selectors; from Mix */
1258         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1259         {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1260         /* Mono selector; from Mix */
1261         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1262         /* Mic selector; Mic */
1263         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x0},
1264         /* Line-in selector: Line-in */
1265         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x0},
1266         /* Mic boost: 0dB */
1267         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1268         /* Record selector: mic */
1269         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1271         /* SPDIF route: PCM */
1272         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1273         /* Front Pin */
1274         {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1275         /* HP Pin */
1276         {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1277         /* Mono Pin */
1278         {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1279         /* Mic Pin */
1280         {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1281         /* Line Pin */
1282         {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1283         { } /* end */
1284 };
1285
1286 #ifdef CONFIG_SND_HDA_POWER_SAVE
1287 static struct hda_amp_list ad1983_loopbacks[] = {
1288         { 0x12, HDA_OUTPUT, 0 }, /* Mic */
1289         { 0x13, HDA_OUTPUT, 0 }, /* Line */
1290         { } /* end */
1291 };
1292 #endif
1293
1294 static int patch_ad1983(struct hda_codec *codec)
1295 {
1296         struct ad198x_spec *spec;
1297
1298         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1299         if (spec == NULL)
1300                 return -ENOMEM;
1301
1302         codec->spec = spec;
1303
1304         spec->multiout.max_channels = 2;
1305         spec->multiout.num_dacs = ARRAY_SIZE(ad1983_dac_nids);
1306         spec->multiout.dac_nids = ad1983_dac_nids;
1307         spec->multiout.dig_out_nid = AD1983_SPDIF_OUT;
1308         spec->num_adc_nids = 1;
1309         spec->adc_nids = ad1983_adc_nids;
1310         spec->capsrc_nids = ad1983_capsrc_nids;
1311         spec->input_mux = &ad1983_capture_source;
1312         spec->num_mixers = 1;
1313         spec->mixers[0] = ad1983_mixers;
1314         spec->num_init_verbs = 1;
1315         spec->init_verbs[0] = ad1983_init_verbs;
1316         spec->spdif_route = 0;
1317 #ifdef CONFIG_SND_HDA_POWER_SAVE
1318         spec->loopback.amplist = ad1983_loopbacks;
1319 #endif
1320         spec->vmaster_nid = 0x05;
1321
1322         codec->patch_ops = ad198x_patch_ops;
1323
1324         return 0;
1325 }
1326
1327
1328 /*
1329  * AD1981 HD specific
1330  */
1331
1332 #define AD1981_SPDIF_OUT        0x02
1333 #define AD1981_DAC              0x03
1334 #define AD1981_ADC              0x04
1335
1336 static hda_nid_t ad1981_dac_nids[1] = { AD1981_DAC };
1337 static hda_nid_t ad1981_adc_nids[1] = { AD1981_ADC };
1338 static hda_nid_t ad1981_capsrc_nids[1] = { 0x15 };
1339
1340 /* 0x0c, 0x09, 0x0e, 0x0f, 0x19, 0x05, 0x18, 0x17 */
1341 static struct hda_input_mux ad1981_capture_source = {
1342         .num_items = 7,
1343         .items = {
1344                 { "Front Mic", 0x0 },
1345                 { "Line", 0x1 },
1346                 { "Mix", 0x2 },
1347                 { "Mix Mono", 0x3 },
1348                 { "CD", 0x4 },
1349                 { "Mic", 0x6 },
1350                 { "Aux", 0x7 },
1351         },
1352 };
1353
1354 static struct snd_kcontrol_new ad1981_mixers[] = {
1355         HDA_CODEC_VOLUME("Front Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1356         HDA_CODEC_MUTE("Front Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1357         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1358         HDA_CODEC_MUTE("Headphone Playback Switch", 0x06, 0x0, HDA_OUTPUT),
1359         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x07, 1, 0x0, HDA_OUTPUT),
1360         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x07, 1, 0x0, HDA_OUTPUT),
1361         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1362         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1363         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1364         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1365         HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1366         HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1367         HDA_CODEC_VOLUME("Aux Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
1368         HDA_CODEC_MUTE("Aux Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
1369         HDA_CODEC_VOLUME("Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1370         HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1371         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1372         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1373         HDA_CODEC_VOLUME_MONO("PC Speaker Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
1374         HDA_CODEC_MUTE_MONO("PC Speaker Playback Switch", 0x0d, 1, 0x0, HDA_OUTPUT),
1375         HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1376         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
1377         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1378         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1379         {
1380                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1381                 .name = "Capture Source",
1382                 .info = ad198x_mux_enum_info,
1383                 .get = ad198x_mux_enum_get,
1384                 .put = ad198x_mux_enum_put,
1385         },
1386         /* identical with AD1983 */
1387         {
1388                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1389                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1390                 .info = ad1983_spdif_route_info,
1391                 .get = ad1983_spdif_route_get,
1392                 .put = ad1983_spdif_route_put,
1393         },
1394         { } /* end */
1395 };
1396
1397 static struct hda_verb ad1981_init_verbs[] = {
1398         /* Front, HP, Mono; mute as default */
1399         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1400         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1401         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1402         /* Beep, PCM, Front Mic, Line, Rear Mic, Aux, CD-In: mute */
1403         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1404         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1405         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1406         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1407         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1408         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1409         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1410         /* Front, HP selectors; from Mix */
1411         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
1412         {0x06, AC_VERB_SET_CONNECT_SEL, 0x01},
1413         /* Mono selector; from Mix */
1414         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x03},
1415         /* Mic Mixer; select Front Mic */
1416         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1417         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1418         /* Mic boost: 0dB */
1419         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1420         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1421         /* Record selector: Front mic */
1422         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},
1423         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1424         /* SPDIF route: PCM */
1425         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0},
1426         /* Front Pin */
1427         {0x05, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1428         /* HP Pin */
1429         {0x06, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
1430         /* Mono Pin */
1431         {0x07, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
1432         /* Front & Rear Mic Pins */
1433         {0x08, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1434         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
1435         /* Line Pin */
1436         {0x09, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
1437         /* Digital Beep */
1438         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
1439         /* Line-Out as Input: disabled */
1440         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1441         { } /* end */
1442 };
1443
1444 #ifdef CONFIG_SND_HDA_POWER_SAVE
1445 static struct hda_amp_list ad1981_loopbacks[] = {
1446         { 0x12, HDA_OUTPUT, 0 }, /* Front Mic */
1447         { 0x13, HDA_OUTPUT, 0 }, /* Line */
1448         { 0x1b, HDA_OUTPUT, 0 }, /* Aux */
1449         { 0x1c, HDA_OUTPUT, 0 }, /* Mic */
1450         { 0x1d, HDA_OUTPUT, 0 }, /* CD */
1451         { } /* end */
1452 };
1453 #endif
1454
1455 /*
1456  * Patch for HP nx6320
1457  *
1458  * nx6320 uses EAPD in the reverse way - EAPD-on means the internal
1459  * speaker output enabled _and_ mute-LED off.
1460  */
1461
1462 #define AD1981_HP_EVENT         0x37
1463 #define AD1981_MIC_EVENT        0x38
1464
1465 static struct hda_verb ad1981_hp_init_verbs[] = {
1466         {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x00 }, /* default off */
1467         /* pin sensing on HP and Mic jacks */
1468         {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1469         {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1470         {}
1471 };
1472
1473 /* turn on/off EAPD (+ mute HP) as a master switch */
1474 static int ad1981_hp_master_sw_put(struct snd_kcontrol *kcontrol,
1475                                    struct snd_ctl_elem_value *ucontrol)
1476 {
1477         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1478         struct ad198x_spec *spec = codec->spec;
1479
1480         if (! ad198x_eapd_put(kcontrol, ucontrol))
1481                 return 0;
1482         /* change speaker pin appropriately */
1483         snd_hda_codec_write(codec, 0x05, 0,
1484                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1485                             spec->cur_eapd ? PIN_OUT : 0);
1486         /* toggle HP mute appropriately */
1487         snd_hda_codec_amp_stereo(codec, 0x06, HDA_OUTPUT, 0,
1488                                  HDA_AMP_MUTE,
1489                                  spec->cur_eapd ? 0 : HDA_AMP_MUTE);
1490         return 1;
1491 }
1492
1493 /* bind volumes of both NID 0x05 and 0x06 */
1494 static struct hda_bind_ctls ad1981_hp_bind_master_vol = {
1495         .ops = &snd_hda_bind_vol,
1496         .values = {
1497                 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT),
1498                 HDA_COMPOSE_AMP_VAL(0x06, 3, 0, HDA_OUTPUT),
1499                 0
1500         },
1501 };
1502
1503 /* mute internal speaker if HP is plugged */
1504 static void ad1981_hp_automute(struct hda_codec *codec)
1505 {
1506         unsigned int present;
1507
1508         present = snd_hda_codec_read(codec, 0x06, 0,
1509                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1510         snd_hda_codec_amp_stereo(codec, 0x05, HDA_OUTPUT, 0,
1511                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
1512 }
1513
1514 /* toggle input of built-in and mic jack appropriately */
1515 static void ad1981_hp_automic(struct hda_codec *codec)
1516 {
1517         static struct hda_verb mic_jack_on[] = {
1518                 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1519                 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1520                 {}
1521         };
1522         static struct hda_verb mic_jack_off[] = {
1523                 {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080},
1524                 {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1525                 {}
1526         };
1527         unsigned int present;
1528
1529         present = snd_hda_codec_read(codec, 0x08, 0,
1530                                  AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
1531         if (present)
1532                 snd_hda_sequence_write(codec, mic_jack_on);
1533         else
1534                 snd_hda_sequence_write(codec, mic_jack_off);
1535 }
1536
1537 /* unsolicited event for HP jack sensing */
1538 static void ad1981_hp_unsol_event(struct hda_codec *codec,
1539                                   unsigned int res)
1540 {
1541         res >>= 26;
1542         switch (res) {
1543         case AD1981_HP_EVENT:
1544                 ad1981_hp_automute(codec);
1545                 break;
1546         case AD1981_MIC_EVENT:
1547                 ad1981_hp_automic(codec);
1548                 break;
1549         }
1550 }
1551
1552 static struct hda_input_mux ad1981_hp_capture_source = {
1553         .num_items = 3,
1554         .items = {
1555                 { "Mic", 0x0 },
1556                 { "Docking-Station", 0x1 },
1557                 { "Mix", 0x2 },
1558         },
1559 };
1560
1561 static struct snd_kcontrol_new ad1981_hp_mixers[] = {
1562         HDA_BIND_VOL("Master Playback Volume", &ad1981_hp_bind_master_vol),
1563         {
1564                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1565                 .name = "Master Playback Switch",
1566                 .info = ad198x_eapd_info,
1567                 .get = ad198x_eapd_get,
1568                 .put = ad1981_hp_master_sw_put,
1569                 .private_value = 0x05,
1570         },
1571         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1572         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1573 #if 0
1574         /* FIXME: analog mic/line loopback doesn't work with my tests...
1575          *        (although recording is OK)
1576          */
1577         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1578         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1579         HDA_CODEC_VOLUME("Docking-Station Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1580         HDA_CODEC_MUTE("Docking-Station Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1581         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x1c, 0x0, HDA_OUTPUT),
1582         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1583         /* FIXME: does this laptop have analog CD connection? */
1584         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1585         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1586 #endif
1587         HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1588         HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
1589         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1590         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1591         {
1592                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1593                 .name = "Capture Source",
1594                 .info = ad198x_mux_enum_info,
1595                 .get = ad198x_mux_enum_get,
1596                 .put = ad198x_mux_enum_put,
1597         },
1598         { } /* end */
1599 };
1600
1601 /* initialize jack-sensing, too */
1602 static int ad1981_hp_init(struct hda_codec *codec)
1603 {
1604         ad198x_init(codec);
1605         ad1981_hp_automute(codec);
1606         ad1981_hp_automic(codec);
1607         return 0;
1608 }
1609
1610 /* configuration for Toshiba Laptops */
1611 static struct hda_verb ad1981_toshiba_init_verbs[] = {
1612         {0x05, AC_VERB_SET_EAPD_BTLENABLE, 0x01 }, /* default on */
1613         /* pin sensing on HP and Mic jacks */
1614         {0x06, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_HP_EVENT},
1615         {0x08, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1981_MIC_EVENT},
1616         {}
1617 };
1618
1619 static struct snd_kcontrol_new ad1981_toshiba_mixers[] = {
1620         HDA_CODEC_VOLUME("Amp Volume", 0x1a, 0x0, HDA_OUTPUT),
1621         HDA_CODEC_MUTE("Amp Switch", 0x1a, 0x0, HDA_OUTPUT),
1622         { }
1623 };
1624
1625 /* configuration for Lenovo Thinkpad T60 */
1626 static struct snd_kcontrol_new ad1981_thinkpad_mixers[] = {
1627         HDA_CODEC_VOLUME("Master Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1628         HDA_CODEC_MUTE("Master Playback Switch", 0x05, 0x0, HDA_OUTPUT),
1629         HDA_CODEC_VOLUME("PCM Playback Volume", 0x11, 0x0, HDA_OUTPUT),
1630         HDA_CODEC_MUTE("PCM Playback Switch", 0x11, 0x0, HDA_OUTPUT),
1631         HDA_CODEC_VOLUME("Mic Playback Volume", 0x12, 0x0, HDA_OUTPUT),
1632         HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1633         HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1634         HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1635         HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1636         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1637         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1638         {
1639                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1640                 .name = "Capture Source",
1641                 .info = ad198x_mux_enum_info,
1642                 .get = ad198x_mux_enum_get,
1643                 .put = ad198x_mux_enum_put,
1644         },
1645         /* identical with AD1983 */
1646         {
1647                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1648                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
1649                 .info = ad1983_spdif_route_info,
1650                 .get = ad1983_spdif_route_get,
1651                 .put = ad1983_spdif_route_put,
1652         },
1653         { } /* end */
1654 };
1655
1656 static struct hda_input_mux ad1981_thinkpad_capture_source = {
1657         .num_items = 3,
1658         .items = {
1659                 { "Mic", 0x0 },
1660                 { "Mix", 0x2 },
1661                 { "CD", 0x4 },
1662         },
1663 };
1664
1665 /* models */
1666 enum {
1667         AD1981_BASIC,
1668         AD1981_HP,
1669         AD1981_THINKPAD,
1670         AD1981_TOSHIBA,
1671         AD1981_MODELS
1672 };
1673
1674 static const char *ad1981_models[AD1981_MODELS] = {
1675         [AD1981_HP]             = "hp",
1676         [AD1981_THINKPAD]       = "thinkpad",
1677         [AD1981_BASIC]          = "basic",
1678         [AD1981_TOSHIBA]        = "toshiba"
1679 };
1680
1681 static struct snd_pci_quirk ad1981_cfg_tbl[] = {
1682         SND_PCI_QUIRK(0x1014, 0x0597, "Lenovo Z60", AD1981_THINKPAD),
1683         SND_PCI_QUIRK(0x1014, 0x05b7, "Lenovo Z60m", AD1981_THINKPAD),
1684         /* All HP models */
1685         SND_PCI_QUIRK(0x103c, 0, "HP nx", AD1981_HP),
1686         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba U205", AD1981_TOSHIBA),
1687         /* Lenovo Thinkpad T60/X60/Z6xx */
1688         SND_PCI_QUIRK(0x17aa, 0, "Lenovo Thinkpad", AD1981_THINKPAD),
1689         /* HP nx6320 (reversed SSID, H/W bug) */
1690         SND_PCI_QUIRK(0x30b0, 0x103c, "HP nx6320", AD1981_HP),
1691         {}
1692 };
1693
1694 static int patch_ad1981(struct hda_codec *codec)
1695 {
1696         struct ad198x_spec *spec;
1697         int board_config;
1698
1699         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1700         if (spec == NULL)
1701                 return -ENOMEM;
1702
1703         codec->spec = spec;
1704
1705         spec->multiout.max_channels = 2;
1706         spec->multiout.num_dacs = ARRAY_SIZE(ad1981_dac_nids);
1707         spec->multiout.dac_nids = ad1981_dac_nids;
1708         spec->multiout.dig_out_nid = AD1981_SPDIF_OUT;
1709         spec->num_adc_nids = 1;
1710         spec->adc_nids = ad1981_adc_nids;
1711         spec->capsrc_nids = ad1981_capsrc_nids;
1712         spec->input_mux = &ad1981_capture_source;
1713         spec->num_mixers = 1;
1714         spec->mixers[0] = ad1981_mixers;
1715         spec->num_init_verbs = 1;
1716         spec->init_verbs[0] = ad1981_init_verbs;
1717         spec->spdif_route = 0;
1718 #ifdef CONFIG_SND_HDA_POWER_SAVE
1719         spec->loopback.amplist = ad1981_loopbacks;
1720 #endif
1721         spec->vmaster_nid = 0x05;
1722
1723         codec->patch_ops = ad198x_patch_ops;
1724
1725         /* override some parameters */
1726         board_config = snd_hda_check_board_config(codec, AD1981_MODELS,
1727                                                   ad1981_models,
1728                                                   ad1981_cfg_tbl);
1729         switch (board_config) {
1730         case AD1981_HP:
1731                 spec->mixers[0] = ad1981_hp_mixers;
1732                 spec->num_init_verbs = 2;
1733                 spec->init_verbs[1] = ad1981_hp_init_verbs;
1734                 spec->multiout.dig_out_nid = 0;
1735                 spec->input_mux = &ad1981_hp_capture_source;
1736
1737                 codec->patch_ops.init = ad1981_hp_init;
1738                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1739                 break;
1740         case AD1981_THINKPAD:
1741                 spec->mixers[0] = ad1981_thinkpad_mixers;
1742                 spec->input_mux = &ad1981_thinkpad_capture_source;
1743                 break;
1744         case AD1981_TOSHIBA:
1745                 spec->mixers[0] = ad1981_hp_mixers;
1746                 spec->mixers[1] = ad1981_toshiba_mixers;
1747                 spec->num_init_verbs = 2;
1748                 spec->init_verbs[1] = ad1981_toshiba_init_verbs;
1749                 spec->multiout.dig_out_nid = 0;
1750                 spec->input_mux = &ad1981_hp_capture_source;
1751                 codec->patch_ops.init = ad1981_hp_init;
1752                 codec->patch_ops.unsol_event = ad1981_hp_unsol_event;
1753                 break;
1754         }
1755         return 0;
1756 }
1757
1758
1759 /*
1760  * AD1988
1761  *
1762  * Output pins and routes
1763  *
1764  *        Pin               Mix     Sel     DAC (*)
1765  * port-A 0x11 (mute/hp) <- 0x22 <- 0x37 <- 03/04/06
1766  * port-B 0x14 (mute/hp) <- 0x2b <- 0x30 <- 03/04/06
1767  * port-C 0x15 (mute)    <- 0x2c <- 0x31 <- 05/0a
1768  * port-D 0x12 (mute/hp) <- 0x29         <- 04
1769  * port-E 0x17 (mute/hp) <- 0x26 <- 0x32 <- 05/0a
1770  * port-F 0x16 (mute)    <- 0x2a         <- 06
1771  * port-G 0x24 (mute)    <- 0x27         <- 05
1772  * port-H 0x25 (mute)    <- 0x28         <- 0a
1773  * mono   0x13 (mute/amp)<- 0x1e <- 0x36 <- 03/04/06
1774  *
1775  * DAC0 = 03h, DAC1 = 04h, DAC2 = 05h, DAC3 = 06h, DAC4 = 0ah
1776  * (*) DAC2/3/4 are swapped to DAC3/4/2 on AD198A rev.2 due to a h/w bug.
1777  *
1778  * Input pins and routes
1779  *
1780  *        pin     boost   mix input # / adc input #
1781  * port-A 0x11 -> 0x38 -> mix 2, ADC 0
1782  * port-B 0x14 -> 0x39 -> mix 0, ADC 1
1783  * port-C 0x15 -> 0x3a -> 33:0 - mix 1, ADC 2
1784  * port-D 0x12 -> 0x3d -> mix 3, ADC 8
1785  * port-E 0x17 -> 0x3c -> 34:0 - mix 4, ADC 4
1786  * port-F 0x16 -> 0x3b -> mix 5, ADC 3
1787  * port-G 0x24 -> N/A  -> 33:1 - mix 1, 34:1 - mix 4, ADC 6
1788  * port-H 0x25 -> N/A  -> 33:2 - mix 1, 34:2 - mix 4, ADC 7
1789  *
1790  *
1791  * DAC assignment
1792  *   6stack - front/surr/CLFE/side/opt DACs - 04/06/05/0a/03
1793  *   3stack - front/surr/CLFE/opt DACs - 04/05/0a/03
1794  *
1795  * Inputs of Analog Mix (0x20)
1796  *   0:Port-B (front mic)
1797  *   1:Port-C/G/H (line-in)
1798  *   2:Port-A
1799  *   3:Port-D (line-in/2)
1800  *   4:Port-E/G/H (mic-in)
1801  *   5:Port-F (mic2-in)
1802  *   6:CD
1803  *   7:Beep
1804  *
1805  * ADC selection
1806  *   0:Port-A
1807  *   1:Port-B (front mic-in)
1808  *   2:Port-C (line-in)
1809  *   3:Port-F (mic2-in)
1810  *   4:Port-E (mic-in)
1811  *   5:CD
1812  *   6:Port-G
1813  *   7:Port-H
1814  *   8:Port-D (line-in/2)
1815  *   9:Mix
1816  *
1817  * Proposed pin assignments by the datasheet
1818  *
1819  * 6-stack
1820  * Port-A front headphone
1821  *      B front mic-in
1822  *      C rear line-in
1823  *      D rear front-out
1824  *      E rear mic-in
1825  *      F rear surround
1826  *      G rear CLFE
1827  *      H rear side
1828  *
1829  * 3-stack
1830  * Port-A front headphone
1831  *      B front mic
1832  *      C rear line-in/surround
1833  *      D rear front-out
1834  *      E rear mic-in/CLFE
1835  *
1836  * laptop
1837  * Port-A headphone
1838  *      B mic-in
1839  *      C docking station
1840  *      D internal speaker (with EAPD)
1841  *      E/F quad mic array
1842  */
1843
1844
1845 /* models */
1846 enum {
1847         AD1988_6STACK,
1848         AD1988_6STACK_DIG,
1849         AD1988_3STACK,
1850         AD1988_3STACK_DIG,
1851         AD1988_LAPTOP,
1852         AD1988_LAPTOP_DIG,
1853         AD1988_AUTO,
1854         AD1988_MODEL_LAST,
1855 };
1856
1857 /* reivision id to check workarounds */
1858 #define AD1988A_REV2            0x100200
1859
1860 #define is_rev2(codec) \
1861         ((codec)->vendor_id == 0x11d41988 && \
1862          (codec)->revision_id == AD1988A_REV2)
1863
1864 /*
1865  * mixers
1866  */
1867
1868 static hda_nid_t ad1988_6stack_dac_nids[4] = {
1869         0x04, 0x06, 0x05, 0x0a
1870 };
1871
1872 static hda_nid_t ad1988_3stack_dac_nids[3] = {
1873         0x04, 0x05, 0x0a
1874 };
1875
1876 /* for AD1988A revision-2, DAC2-4 are swapped */
1877 static hda_nid_t ad1988_6stack_dac_nids_rev2[4] = {
1878         0x04, 0x05, 0x0a, 0x06
1879 };
1880
1881 static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
1882         0x04, 0x0a, 0x06
1883 };
1884
1885 static hda_nid_t ad1988_adc_nids[3] = {
1886         0x08, 0x09, 0x0f
1887 };
1888
1889 static hda_nid_t ad1988_capsrc_nids[3] = {
1890         0x0c, 0x0d, 0x0e
1891 };
1892
1893 #define AD1988_SPDIF_OUT                0x02
1894 #define AD1988_SPDIF_OUT_HDMI   0x0b
1895 #define AD1988_SPDIF_IN         0x07
1896
1897 static hda_nid_t ad1989b_slave_dig_outs[] = {
1898         AD1988_SPDIF_OUT, AD1988_SPDIF_OUT_HDMI, 0
1899 };
1900
1901 static struct hda_input_mux ad1988_6stack_capture_source = {
1902         .num_items = 5,
1903         .items = {
1904                 { "Front Mic", 0x1 },   /* port-B */
1905                 { "Line", 0x2 },        /* port-C */
1906                 { "Mic", 0x4 },         /* port-E */
1907                 { "CD", 0x5 },
1908                 { "Mix", 0x9 },
1909         },
1910 };
1911
1912 static struct hda_input_mux ad1988_laptop_capture_source = {
1913         .num_items = 3,
1914         .items = {
1915                 { "Mic/Line", 0x1 },    /* port-B */
1916                 { "CD", 0x5 },
1917                 { "Mix", 0x9 },
1918         },
1919 };
1920
1921 /*
1922  */
1923 static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
1924                                struct snd_ctl_elem_info *uinfo)
1925 {
1926         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1927         struct ad198x_spec *spec = codec->spec;
1928         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
1929                                     spec->num_channel_mode);
1930 }
1931
1932 static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
1933                               struct snd_ctl_elem_value *ucontrol)
1934 {
1935         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1936         struct ad198x_spec *spec = codec->spec;
1937         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
1938                                    spec->num_channel_mode, spec->multiout.max_channels);
1939 }
1940
1941 static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
1942                               struct snd_ctl_elem_value *ucontrol)
1943 {
1944         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1945         struct ad198x_spec *spec = codec->spec;
1946         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
1947                                       spec->num_channel_mode,
1948                                       &spec->multiout.max_channels);
1949         if (err >= 0 && spec->need_dac_fix)
1950                 spec->multiout.num_dacs = spec->multiout.max_channels / 2;
1951         return err;
1952 }
1953
1954 /* 6-stack mode */
1955 static struct snd_kcontrol_new ad1988_6stack_mixers1[] = {
1956         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1957         HDA_CODEC_VOLUME("Surround Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1958         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
1959         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
1960         HDA_CODEC_VOLUME("Side Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
1961         { } /* end */
1962 };
1963
1964 static struct snd_kcontrol_new ad1988_6stack_mixers1_rev2[] = {
1965         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
1966         HDA_CODEC_VOLUME("Surround Playback Volume", 0x05, 0x0, HDA_OUTPUT),
1967         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
1968         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0a, 2, 0x0, HDA_OUTPUT),
1969         HDA_CODEC_VOLUME("Side Playback Volume", 0x06, 0x0, HDA_OUTPUT),
1970         { } /* end */
1971 };
1972
1973 static struct snd_kcontrol_new ad1988_6stack_mixers2[] = {
1974         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
1975         HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
1976         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
1977         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
1978         HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
1979         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
1980         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
1981
1982         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
1983         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
1984         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
1985         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
1986         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
1987         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
1988         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
1989         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
1990
1991         HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
1992         HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
1993
1994         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
1995         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
1996
1997         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
1998         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
1999
2000         { } /* end */
2001 };
2002
2003 /* 3-stack mode */
2004 static struct snd_kcontrol_new ad1988_3stack_mixers1[] = {
2005         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2006         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2007         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x05, 1, 0x0, HDA_OUTPUT),
2008         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x05, 2, 0x0, HDA_OUTPUT),
2009         { } /* end */
2010 };
2011
2012 static struct snd_kcontrol_new ad1988_3stack_mixers1_rev2[] = {
2013         HDA_CODEC_VOLUME("Front Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2014         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0a, 0x0, HDA_OUTPUT),
2015         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x06, 1, 0x0, HDA_OUTPUT),
2016         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x06, 2, 0x0, HDA_OUTPUT),
2017         { } /* end */
2018 };
2019
2020 static struct snd_kcontrol_new ad1988_3stack_mixers2[] = {
2021         HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
2022         HDA_BIND_MUTE("Surround Playback Switch", 0x2c, 2, HDA_INPUT),
2023         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x26, 1, 2, HDA_INPUT),
2024         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x26, 2, 2, HDA_INPUT),
2025         HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
2026         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2027
2028         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2029         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2030         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2031         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2032         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2033         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2034         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
2035         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
2036
2037         HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2038         HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2039
2040         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2041         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2042
2043         HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2044         HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
2045         {
2046                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2047                 .name = "Channel Mode",
2048                 .info = ad198x_ch_mode_info,
2049                 .get = ad198x_ch_mode_get,
2050                 .put = ad198x_ch_mode_put,
2051         },
2052
2053         { } /* end */
2054 };
2055
2056 /* laptop mode */
2057 static struct snd_kcontrol_new ad1988_laptop_mixers[] = {
2058         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
2059         HDA_CODEC_MUTE("PCM Playback Switch", 0x29, 0x0, HDA_INPUT),
2060         HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
2061
2062         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
2063         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
2064         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
2065         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
2066         HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
2067         HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
2068
2069         HDA_CODEC_VOLUME("Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
2070         HDA_CODEC_MUTE("Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
2071
2072         HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2073         HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2074
2075         HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2076
2077         {
2078                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2079                 .name = "External Amplifier",
2080                 .info = ad198x_eapd_info,
2081                 .get = ad198x_eapd_get,
2082                 .put = ad198x_eapd_put,
2083                 .private_value = 0x12 | (1 << 8), /* port-D, inversed */
2084         },
2085
2086         { } /* end */
2087 };
2088
2089 /* capture */
2090 static struct snd_kcontrol_new ad1988_capture_mixers[] = {
2091         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
2092         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
2093         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
2094         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
2095         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x0e, 0x0, HDA_OUTPUT),
2096         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x0e, 0x0, HDA_OUTPUT),
2097         {
2098                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2099                 /* The multiple "Capture Source" controls confuse alsamixer
2100                  * So call somewhat different..
2101                  */
2102                 /* .name = "Capture Source", */
2103                 .name = "Input Source",
2104                 .count = 3,
2105                 .info = ad198x_mux_enum_info,
2106                 .get = ad198x_mux_enum_get,
2107                 .put = ad198x_mux_enum_put,
2108         },
2109         { } /* end */
2110 };
2111
2112 static int ad1988_spdif_playback_source_info(struct snd_kcontrol *kcontrol,
2113                                              struct snd_ctl_elem_info *uinfo)
2114 {
2115         static char *texts[] = {
2116                 "PCM", "ADC1", "ADC2", "ADC3"
2117         };
2118         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2119         uinfo->count = 1;
2120         uinfo->value.enumerated.items = 4;
2121         if (uinfo->value.enumerated.item >= 4)
2122                 uinfo->value.enumerated.item = 3;
2123         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
2124         return 0;
2125 }
2126
2127 static int ad1988_spdif_playback_source_get(struct snd_kcontrol *kcontrol,
2128                                             struct snd_ctl_elem_value *ucontrol)
2129 {
2130         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2131         unsigned int sel;
2132
2133         sel = snd_hda_codec_read(codec, 0x1d, 0, AC_VERB_GET_AMP_GAIN_MUTE,
2134                                  AC_AMP_GET_INPUT);
2135         if (!(sel & 0x80))
2136                 ucontrol->value.enumerated.item[0] = 0;
2137         else {
2138                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2139                                          AC_VERB_GET_CONNECT_SEL, 0);
2140                 if (sel < 3)
2141                         sel++;
2142                 else
2143                         sel = 0;
2144                 ucontrol->value.enumerated.item[0] = sel;
2145         }
2146         return 0;
2147 }
2148
2149 static int ad1988_spdif_playback_source_put(struct snd_kcontrol *kcontrol,
2150                                             struct snd_ctl_elem_value *ucontrol)
2151 {
2152         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2153         unsigned int val, sel;
2154         int change;
2155
2156         val = ucontrol->value.enumerated.item[0];
2157         if (val > 3)
2158                 return -EINVAL;
2159         if (!val) {
2160                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2161                                          AC_VERB_GET_AMP_GAIN_MUTE,
2162                                          AC_AMP_GET_INPUT);
2163                 change = sel & 0x80;
2164                 if (change) {
2165                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2166                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2167                                                   AMP_IN_UNMUTE(0));
2168                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2169                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2170                                                   AMP_IN_MUTE(1));
2171                 }
2172         } else {
2173                 sel = snd_hda_codec_read(codec, 0x1d, 0,
2174                                          AC_VERB_GET_AMP_GAIN_MUTE,
2175                                          AC_AMP_GET_INPUT | 0x01);
2176                 change = sel & 0x80;
2177                 if (change) {
2178                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2179                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2180                                                   AMP_IN_MUTE(0));
2181                         snd_hda_codec_write_cache(codec, 0x1d, 0,
2182                                                   AC_VERB_SET_AMP_GAIN_MUTE,
2183                                                   AMP_IN_UNMUTE(1));
2184                 }
2185                 sel = snd_hda_codec_read(codec, 0x0b, 0,
2186                                          AC_VERB_GET_CONNECT_SEL, 0) + 1;
2187                 change |= sel != val;
2188                 if (change)
2189                         snd_hda_codec_write_cache(codec, 0x0b, 0,
2190                                                   AC_VERB_SET_CONNECT_SEL,
2191                                                   val - 1);
2192         }
2193         return change;
2194 }
2195
2196 static struct snd_kcontrol_new ad1988_spdif_out_mixers[] = {
2197         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2198         {
2199                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2200                 .name = "IEC958 Playback Source",
2201                 .info = ad1988_spdif_playback_source_info,
2202                 .get = ad1988_spdif_playback_source_get,
2203                 .put = ad1988_spdif_playback_source_put,
2204         },
2205         { } /* end */
2206 };
2207
2208 static struct snd_kcontrol_new ad1988_spdif_in_mixers[] = {
2209         HDA_CODEC_VOLUME("IEC958 Capture Volume", 0x1c, 0x0, HDA_INPUT),
2210         { } /* end */
2211 };
2212
2213 static struct snd_kcontrol_new ad1989_spdif_out_mixers[] = {
2214         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
2215         HDA_CODEC_VOLUME("HDMI Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
2216         { } /* end */
2217 };
2218
2219 /*
2220  * initialization verbs
2221  */
2222
2223 /*
2224  * for 6-stack (+dig)
2225  */
2226 static struct hda_verb ad1988_6stack_init_verbs[] = {
2227         /* Front, Surround, CLFE, side DAC; unmute as default */
2228         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2229         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2230         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2231         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2232         /* Port-A front headphon path */
2233         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2234         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2235         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2236         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2237         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2238         /* Port-D line-out path */
2239         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2240         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2241         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2242         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2243         /* Port-F surround path */
2244         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2245         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2246         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2247         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2248         /* Port-G CLFE path */
2249         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2250         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2251         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2252         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2253         /* Port-H side path */
2254         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2255         {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2256         {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2257         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2258         /* Mono out path */
2259         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2260         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2261         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2262         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2263         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2264         /* Port-B front mic-in path */
2265         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2266         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2267         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2268         /* Port-C line-in path */
2269         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2270         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2271         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2272         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2273         /* Port-E mic-in path */
2274         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2275         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2276         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2277         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2278         /* Analog CD Input */
2279         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2280         /* Analog Mix output amp */
2281         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2282
2283         { }
2284 };
2285
2286 static struct hda_verb ad1988_capture_init_verbs[] = {
2287         /* mute analog mix */
2288         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2289         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2290         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2291         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2292         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2293         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2294         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2295         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2296         /* select ADCs - front-mic */
2297         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2298         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2299         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2300         /* ADCs; muted */
2301         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2302         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2303         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2304
2305         { }
2306 };
2307
2308 static struct hda_verb ad1988_spdif_init_verbs[] = {
2309         /* SPDIF out sel */
2310         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
2311         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x0}, /* ADC1 */
2312         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2313         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2314         /* SPDIF out pin */
2315         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2316
2317         { }
2318 };
2319
2320 /* AD1989 has no ADC -> SPDIF route */
2321 static struct hda_verb ad1989_spdif_init_verbs[] = {
2322         /* SPDIF-1 out pin */
2323         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2324         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2325         /* SPDIF-2/HDMI out pin */
2326         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2327         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
2328         { }
2329 };
2330
2331 /*
2332  * verbs for 3stack (+dig)
2333  */
2334 static struct hda_verb ad1988_3stack_ch2_init[] = {
2335         /* set port-C to line-in */
2336         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2337         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2338         /* set port-E to mic-in */
2339         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2340         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2341         { } /* end */
2342 };
2343
2344 static struct hda_verb ad1988_3stack_ch6_init[] = {
2345         /* set port-C to surround out */
2346         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2347         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2348         /* set port-E to CLFE out */
2349         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2350         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2351         { } /* end */
2352 };
2353
2354 static struct hda_channel_mode ad1988_3stack_modes[2] = {
2355         { 2, ad1988_3stack_ch2_init },
2356         { 6, ad1988_3stack_ch6_init },
2357 };
2358
2359 static struct hda_verb ad1988_3stack_init_verbs[] = {
2360         /* Front, Surround, CLFE, side DAC; unmute as default */
2361         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2362         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2363         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2364         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2365         /* Port-A front headphon path */
2366         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2367         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2368         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2369         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2370         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2371         /* Port-D line-out path */
2372         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2373         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2374         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2375         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2376         /* Mono out path */
2377         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2378         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2379         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2380         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2381         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2382         /* Port-B front mic-in path */
2383         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2384         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2385         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2386         /* Port-C line-in/surround path - 6ch mode as default */
2387         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2388         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2389         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2390         {0x31, AC_VERB_SET_CONNECT_SEL, 0x0}, /* output sel: DAC 0x05 */
2391         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2392         /* Port-E mic-in/CLFE path - 6ch mode as default */
2393         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2394         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2395         {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2396         {0x32, AC_VERB_SET_CONNECT_SEL, 0x1}, /* output sel: DAC 0x0a */
2397         {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
2398         /* mute analog mix */
2399         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2400         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2401         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2402         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2403         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2404         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2405         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2406         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2407         /* select ADCs - front-mic */
2408         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2409         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2410         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2411         /* ADCs; muted */
2412         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2413         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2414         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2415         /* Analog Mix output amp */
2416         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2417         { }
2418 };
2419
2420 /*
2421  * verbs for laptop mode (+dig)
2422  */
2423 static struct hda_verb ad1988_laptop_hp_on[] = {
2424         /* unmute port-A and mute port-D */
2425         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2426         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2427         { } /* end */
2428 };
2429 static struct hda_verb ad1988_laptop_hp_off[] = {
2430         /* mute port-A and unmute port-D */
2431         { 0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2432         { 0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2433         { } /* end */
2434 };
2435
2436 #define AD1988_HP_EVENT 0x01
2437
2438 static struct hda_verb ad1988_laptop_init_verbs[] = {
2439         /* Front, Surround, CLFE, side DAC; unmute as default */
2440         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2441         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2442         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2443         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2444         /* Port-A front headphon path */
2445         {0x37, AC_VERB_SET_CONNECT_SEL, 0x01}, /* DAC1:04h */
2446         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2448         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2449         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2450         /* unsolicited event for pin-sense */
2451         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | AD1988_HP_EVENT },
2452         /* Port-D line-out path + EAPD */
2453         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2454         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2455         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2456         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2457         {0x12, AC_VERB_SET_EAPD_BTLENABLE, 0x00}, /* EAPD-off */
2458         /* Mono out path */
2459         {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
2460         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2461         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2462         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2463         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
2464         /* Port-B mic-in path */
2465         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2466         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2467         {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2468         /* Port-C docking station - try to output */
2469         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2470         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2471         {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2472         {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
2473         /* mute analog mix */
2474         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2475         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2476         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2477         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2478         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2479         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
2480         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2481         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2482         /* select ADCs - mic */
2483         {0x0c, AC_VERB_SET_CONNECT_SEL, 0x1},
2484         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x1},
2485         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
2486         /* ADCs; muted */
2487         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2488         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2489         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2490         /* Analog Mix output amp */
2491         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
2492         { }
2493 };
2494
2495 static void ad1988_laptop_unsol_event(struct hda_codec *codec, unsigned int res)
2496 {
2497         if ((res >> 26) != AD1988_HP_EVENT)
2498                 return;
2499         if (snd_hda_codec_read(codec, 0x11, 0, AC_VERB_GET_PIN_SENSE, 0) & (1 << 31))
2500                 snd_hda_sequence_write(codec, ad1988_laptop_hp_on);
2501         else
2502                 snd_hda_sequence_write(codec, ad1988_laptop_hp_off);
2503
2504
2505 #ifdef CONFIG_SND_HDA_POWER_SAVE
2506 static struct hda_amp_list ad1988_loopbacks[] = {
2507         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
2508         { 0x20, HDA_INPUT, 1 }, /* Line */
2509         { 0x20, HDA_INPUT, 4 }, /* Mic */
2510         { 0x20, HDA_INPUT, 6 }, /* CD */
2511         { } /* end */
2512 };
2513 #endif
2514
2515 /*
2516  * Automatic parse of I/O pins from the BIOS configuration
2517  */
2518
2519 enum {
2520         AD_CTL_WIDGET_VOL,
2521         AD_CTL_WIDGET_MUTE,
2522         AD_CTL_BIND_MUTE,
2523 };
2524 static struct snd_kcontrol_new ad1988_control_templates[] = {
2525         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2526         HDA_CODEC_MUTE(NULL, 0, 0, 0),
2527         HDA_BIND_MUTE(NULL, 0, 0, 0),
2528 };
2529
2530 /* add dynamic controls */
2531 static int add_control(struct ad198x_spec *spec, int type, const char *name,
2532                        unsigned long val)
2533 {
2534         struct snd_kcontrol_new *knew;
2535
2536         snd_array_init(&spec->kctls, sizeof(*knew), 32);
2537         knew = snd_array_new(&spec->kctls);
2538         if (!knew)
2539                 return -ENOMEM;
2540         *knew = ad1988_control_templates[type];
2541         knew->name = kstrdup(name, GFP_KERNEL);
2542         if (! knew->name)
2543                 return -ENOMEM;
2544         knew->private_value = val;
2545         return 0;
2546 }
2547
2548 #define AD1988_PIN_CD_NID               0x18
2549 #define AD1988_PIN_BEEP_NID             0x10
2550
2551 static hda_nid_t ad1988_mixer_nids[8] = {
2552         /* A     B     C     D     E     F     G     H */
2553         0x22, 0x2b, 0x2c, 0x29, 0x26, 0x2a, 0x27, 0x28
2554 };
2555
2556 static inline hda_nid_t ad1988_idx_to_dac(struct hda_codec *codec, int idx)
2557 {
2558         static hda_nid_t idx_to_dac[8] = {
2559                 /* A     B     C     D     E     F     G     H */
2560                 0x04, 0x06, 0x05, 0x04, 0x0a, 0x06, 0x05, 0x0a
2561         };
2562         static hda_nid_t idx_to_dac_rev2[8] = {
2563                 /* A     B     C     D     E     F     G     H */
2564                 0x04, 0x05, 0x0a, 0x04, 0x06, 0x05, 0x0a, 0x06
2565         };
2566         if (is_rev2(codec))
2567                 return idx_to_dac_rev2[idx];
2568         else
2569                 return idx_to_dac[idx];
2570 }
2571
2572 static hda_nid_t ad1988_boost_nids[8] = {
2573         0x38, 0x39, 0x3a, 0x3d, 0x3c, 0x3b, 0, 0
2574 };
2575
2576 static int ad1988_pin_idx(hda_nid_t nid)
2577 {
2578         static hda_nid_t ad1988_io_pins[8] = {
2579                 0x11, 0x14, 0x15, 0x12, 0x17, 0x16, 0x24, 0x25
2580         };
2581         int i;
2582         for (i = 0; i < ARRAY_SIZE(ad1988_io_pins); i++)
2583                 if (ad1988_io_pins[i] == nid)
2584                         return i;
2585         return 0; /* should be -1 */
2586 }
2587
2588 static int ad1988_pin_to_loopback_idx(hda_nid_t nid)
2589 {
2590         static int loopback_idx[8] = {
2591                 2, 0, 1, 3, 4, 5, 1, 4
2592         };
2593         switch (nid) {
2594         case AD1988_PIN_CD_NID:
2595                 return 6;
2596         default:
2597                 return loopback_idx[ad1988_pin_idx(nid)];
2598         }
2599 }
2600
2601 static int ad1988_pin_to_adc_idx(hda_nid_t nid)
2602 {
2603         static int adc_idx[8] = {
2604                 0, 1, 2, 8, 4, 3, 6, 7
2605         };
2606         switch (nid) {
2607         case AD1988_PIN_CD_NID:
2608                 return 5;
2609         default:
2610                 return adc_idx[ad1988_pin_idx(nid)];
2611         }
2612 }
2613
2614 /* fill in the dac_nids table from the parsed pin configuration */
2615 static int ad1988_auto_fill_dac_nids(struct hda_codec *codec,
2616                                      const struct auto_pin_cfg *cfg)
2617 {
2618         struct ad198x_spec *spec = codec->spec;
2619         int i, idx;
2620
2621         spec->multiout.dac_nids = spec->private_dac_nids;
2622
2623         /* check the pins hardwired to audio widget */
2624         for (i = 0; i < cfg->line_outs; i++) {
2625                 idx = ad1988_pin_idx(cfg->line_out_pins[i]);
2626                 spec->multiout.dac_nids[i] = ad1988_idx_to_dac(codec, idx);
2627         }
2628         spec->multiout.num_dacs = cfg->line_outs;
2629         return 0;
2630 }
2631
2632 /* add playback controls from the parsed DAC table */
2633 static int ad1988_auto_create_multi_out_ctls(struct ad198x_spec *spec,
2634                                              const struct auto_pin_cfg *cfg)
2635 {
2636         char name[32];
2637         static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
2638         hda_nid_t nid;
2639         int i, err;
2640
2641         for (i = 0; i < cfg->line_outs; i++) {
2642                 hda_nid_t dac = spec->multiout.dac_nids[i];
2643                 if (! dac)
2644                         continue;
2645                 nid = ad1988_mixer_nids[ad1988_pin_idx(cfg->line_out_pins[i])];
2646                 if (i == 2) {
2647                         /* Center/LFE */
2648                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2649                                           "Center Playback Volume",
2650                                           HDA_COMPOSE_AMP_VAL(dac, 1, 0, HDA_OUTPUT));
2651                         if (err < 0)
2652                                 return err;
2653                         err = add_control(spec, AD_CTL_WIDGET_VOL,
2654                                           "LFE Playback Volume",
2655                                           HDA_COMPOSE_AMP_VAL(dac, 2, 0, HDA_OUTPUT));
2656                         if (err < 0)
2657                                 return err;
2658                         err = add_control(spec, AD_CTL_BIND_MUTE,
2659                                           "Center Playback Switch",
2660                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2, HDA_INPUT));
2661                         if (err < 0)
2662                                 return err;
2663                         err = add_control(spec, AD_CTL_BIND_MUTE,
2664                                           "LFE Playback Switch",
2665                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2, HDA_INPUT));
2666                         if (err < 0)
2667                                 return err;
2668                 } else {
2669                         sprintf(name, "%s Playback Volume", chname[i]);
2670                         err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2671                                           HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT));
2672                         if (err < 0)
2673                                 return err;
2674                         sprintf(name, "%s Playback Switch", chname[i]);
2675                         err = add_control(spec, AD_CTL_BIND_MUTE, name,
2676                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
2677                         if (err < 0)
2678                                 return err;
2679                 }
2680         }
2681         return 0;
2682 }
2683
2684 /* add playback controls for speaker and HP outputs */
2685 static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
2686                                         const char *pfx)
2687 {
2688         struct ad198x_spec *spec = codec->spec;
2689         hda_nid_t nid;
2690         int i, idx, err;
2691         char name[32];
2692
2693         if (! pin)
2694                 return 0;
2695
2696         idx = ad1988_pin_idx(pin);
2697         nid = ad1988_idx_to_dac(codec, idx);
2698         /* check whether the corresponding DAC was already taken */
2699         for (i = 0; i < spec->autocfg.line_outs; i++) {
2700                 hda_nid_t pin = spec->autocfg.line_out_pins[i];
2701                 hda_nid_t dac = ad1988_idx_to_dac(codec, ad1988_pin_idx(pin));
2702                 if (dac == nid)
2703                         break;
2704         }
2705         if (i >= spec->autocfg.line_outs) {
2706                 /* specify the DAC as the extra output */
2707                 if (!spec->multiout.hp_nid)
2708                         spec->multiout.hp_nid = nid;
2709                 else
2710                         spec->multiout.extra_out_nid[0] = nid;
2711                 /* control HP volume/switch on the output mixer amp */
2712                 sprintf(name, "%s Playback Volume", pfx);
2713                 err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2714                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
2715                 if (err < 0)
2716                         return err;
2717         }
2718         nid = ad1988_mixer_nids[idx];
2719         sprintf(name, "%s Playback Switch", pfx);
2720         if ((err = add_control(spec, AD_CTL_BIND_MUTE, name,
2721                                HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT))) < 0)
2722                 return err;
2723         return 0;
2724 }
2725
2726 /* create input playback/capture controls for the given pin */
2727 static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2728                             const char *ctlname, int boost)
2729 {
2730         char name[32];
2731         int err, idx;
2732
2733         sprintf(name, "%s Playback Volume", ctlname);
2734         idx = ad1988_pin_to_loopback_idx(pin);
2735         if ((err = add_control(spec, AD_CTL_WIDGET_VOL, name,
2736                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2737                 return err;
2738         sprintf(name, "%s Playback Switch", ctlname);
2739         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE, name,
2740                                HDA_COMPOSE_AMP_VAL(0x20, 3, idx, HDA_INPUT))) < 0)
2741                 return err;
2742         if (boost) {
2743                 hda_nid_t bnid;
2744                 idx = ad1988_pin_idx(pin);
2745                 bnid = ad1988_boost_nids[idx];
2746                 if (bnid) {
2747                         sprintf(name, "%s Boost", ctlname);
2748                         return add_control(spec, AD_CTL_WIDGET_VOL, name,
2749                                            HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2750
2751                 }
2752         }
2753         return 0;
2754 }
2755
2756 /* create playback/capture controls for input pins */
2757 static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
2758                                                 const struct auto_pin_cfg *cfg)
2759 {
2760         struct hda_input_mux *imux = &spec->private_imux;
2761         int i, err;
2762
2763         for (i = 0; i < AUTO_PIN_LAST; i++) {
2764                 err = new_analog_input(spec, cfg->input_pins[i],
2765                                        auto_pin_cfg_labels[i],
2766                                        i <= AUTO_PIN_FRONT_MIC);
2767                 if (err < 0)
2768                         return err;
2769                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2770                 imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2771                 imux->num_items++;
2772         }
2773         imux->items[imux->num_items].label = "Mix";
2774         imux->items[imux->num_items].index = 9;
2775         imux->num_items++;
2776
2777         if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2778                                "Analog Mix Playback Volume",
2779                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2780                 return err;
2781         if ((err = add_control(spec, AD_CTL_WIDGET_MUTE,
2782                                "Analog Mix Playback Switch",
2783                                HDA_COMPOSE_AMP_VAL(0x21, 3, 0x0, HDA_OUTPUT))) < 0)
2784                 return err;
2785
2786         return 0;
2787 }
2788
2789 static void ad1988_auto_set_output_and_unmute(struct hda_codec *codec,
2790                                               hda_nid_t nid, int pin_type,
2791                                               int dac_idx)
2792 {
2793         /* set as output */
2794         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2795         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
2796         switch (nid) {
2797         case 0x11: /* port-A - DAC 04 */
2798                 snd_hda_codec_write(codec, 0x37, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2799                 break;
2800         case 0x14: /* port-B - DAC 06 */
2801                 snd_hda_codec_write(codec, 0x30, 0, AC_VERB_SET_CONNECT_SEL, 0x02);
2802                 break;
2803         case 0x15: /* port-C - DAC 05 */
2804                 snd_hda_codec_write(codec, 0x31, 0, AC_VERB_SET_CONNECT_SEL, 0x00);
2805                 break;
2806         case 0x17: /* port-E - DAC 0a */
2807                 snd_hda_codec_write(codec, 0x32, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2808                 break;
2809         case 0x13: /* mono - DAC 04 */
2810                 snd_hda_codec_write(codec, 0x36, 0, AC_VERB_SET_CONNECT_SEL, 0x01);
2811                 break;
2812         }
2813 }
2814
2815 static void ad1988_auto_init_multi_out(struct hda_codec *codec)
2816 {
2817         struct ad198x_spec *spec = codec->spec;
2818         int i;
2819
2820         for (i = 0; i < spec->autocfg.line_outs; i++) {
2821                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
2822                 ad1988_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
2823         }
2824 }
2825
2826 static void ad1988_auto_init_extra_out(struct hda_codec *codec)
2827 {
2828         struct ad198x_spec *spec = codec->spec;
2829         hda_nid_t pin;
2830
2831         pin = spec->autocfg.speaker_pins[0];
2832         if (pin) /* connect to front */
2833                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
2834         pin = spec->autocfg.hp_pins[0];
2835         if (pin) /* connect to front */
2836                 ad1988_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
2837 }
2838
2839 static void ad1988_auto_init_analog_input(struct hda_codec *codec)
2840 {
2841         struct ad198x_spec *spec = codec->spec;
2842         int i, idx;
2843
2844         for (i = 0; i < AUTO_PIN_LAST; i++) {
2845                 hda_nid_t nid = spec->autocfg.input_pins[i];
2846                 if (! nid)
2847                         continue;
2848                 switch (nid) {
2849                 case 0x15: /* port-C */
2850                         snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2851                         break;
2852                 case 0x17: /* port-E */
2853                         snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
2854                         break;
2855                 }
2856                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
2857                                     i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
2858                 if (nid != AD1988_PIN_CD_NID)
2859                         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
2860                                             AMP_OUT_MUTE);
2861                 idx = ad1988_pin_idx(nid);
2862                 if (ad1988_boost_nids[idx])
2863                         snd_hda_codec_write(codec, ad1988_boost_nids[idx], 0,
2864                                             AC_VERB_SET_AMP_GAIN_MUTE,
2865                                             AMP_OUT_ZERO);
2866         }
2867 }
2868
2869 /* parse the BIOS configuration and set up the alc_spec */
2870 /* return 1 if successful, 0 if the proper config is not found, or a negative error code */
2871 static int ad1988_parse_auto_config(struct hda_codec *codec)
2872 {
2873         struct ad198x_spec *spec = codec->spec;
2874         int err;
2875
2876         if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
2877                 return err;
2878         if ((err = ad1988_auto_fill_dac_nids(codec, &spec->autocfg)) < 0)
2879                 return err;
2880         if (! spec->autocfg.line_outs)
2881                 return 0; /* can't find valid BIOS pin config */
2882         if ((err = ad1988_auto_create_multi_out_ctls(spec, &spec->autocfg)) < 0 ||
2883             (err = ad1988_auto_create_extra_out(codec,
2884                                                 spec->autocfg.speaker_pins[0],
2885                                                 "Speaker")) < 0 ||
2886             (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
2887                                                 "Headphone")) < 0 ||
2888             (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
2889                 return err;
2890
2891         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2892
2893         if (spec->autocfg.dig_out_pin)
2894                 spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2895         if (spec->autocfg.dig_in_pin)
2896                 spec->dig_in_nid = AD1988_SPDIF_IN;
2897
2898         if (spec->kctls.list)
2899                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2900
2901         spec->init_verbs[spec->num_init_verbs++] = ad1988_6stack_init_verbs;
2902
2903         spec->input_mux = &spec->private_imux;
2904
2905         return 1;
2906 }
2907
2908 /* init callback for auto-configuration model -- overriding the default init */
2909 static int ad1988_auto_init(struct hda_codec *codec)
2910 {
2911         ad198x_init(codec);
2912         ad1988_auto_init_multi_out(codec);
2913         ad1988_auto_init_extra_out(codec);
2914         ad1988_auto_init_analog_input(codec);
2915         return 0;
2916 }
2917
2918
2919 /*
2920  */
2921
2922 static const char *ad1988_models[AD1988_MODEL_LAST] = {
2923         [AD1988_6STACK]         = "6stack",
2924         [AD1988_6STACK_DIG]     = "6stack-dig",
2925         [AD1988_3STACK]         = "3stack",
2926         [AD1988_3STACK_DIG]     = "3stack-dig",
2927         [AD1988_LAPTOP]         = "laptop",
2928         [AD1988_LAPTOP_DIG]     = "laptop-dig",
2929         [AD1988_AUTO]           = "auto",
2930 };
2931
2932 static struct snd_pci_quirk ad1988_cfg_tbl[] = {
2933         SND_PCI_QUIRK(0x1043, 0x81ec, "Asus P5B-DLX", AD1988_6STACK_DIG),
2934         SND_PCI_QUIRK(0x1043, 0x81f6, "Asus M2N-SLI", AD1988_6STACK_DIG),
2935         SND_PCI_QUIRK(0x1043, 0x8277, "Asus P5K-E/WIFI-AP", AD1988_6STACK_DIG),
2936         SND_PCI_QUIRK(0x1043, 0x8311, "Asus P5Q-Premium/Pro", AD1988_6STACK_DIG),
2937         {}
2938 };
2939
2940 static int patch_ad1988(struct hda_codec *codec)
2941 {
2942         struct ad198x_spec *spec;
2943         int board_config;
2944
2945         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2946         if (spec == NULL)
2947                 return -ENOMEM;
2948
2949         codec->spec = spec;
2950
2951         if (is_rev2(codec))
2952                 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
2953
2954         board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
2955                                                   ad1988_models, ad1988_cfg_tbl);
2956         if (board_config < 0) {
2957                 printk(KERN_INFO "hda_codec: Unknown model for AD1988, trying auto-probe from BIOS...\n");
2958                 board_config = AD1988_AUTO;
2959         }
2960
2961         if (board_config == AD1988_AUTO) {
2962                 /* automatic parse from the BIOS config */
2963                 int err = ad1988_parse_auto_config(codec);
2964                 if (err < 0) {
2965                         ad198x_free(codec);
2966                         return err;
2967                 } else if (! err) {
2968                         printk(KERN_INFO "hda_codec: Cannot set up configuration from BIOS.  Using 6-stack mode...\n");
2969                         board_config = AD1988_6STACK;
2970                 }
2971         }
2972
2973         switch (board_config) {
2974         case AD1988_6STACK:
2975         case AD1988_6STACK_DIG:
2976                 spec->multiout.max_channels = 8;
2977                 spec->multiout.num_dacs = 4;
2978                 if (is_rev2(codec))
2979                         spec->multiout.dac_nids = ad1988_6stack_dac_nids_rev2;
2980                 else
2981                         spec->multiout.dac_nids = ad1988_6stack_dac_nids;
2982                 spec->input_mux = &ad1988_6stack_capture_source;
2983                 spec->num_mixers = 2;
2984                 if (is_rev2(codec))
2985                         spec->mixers[0] = ad1988_6stack_mixers1_rev2;
2986                 else
2987                         spec->mixers[0] = ad1988_6stack_mixers1;
2988                 spec->mixers[1] = ad1988_6stack_mixers2;
2989                 spec->num_init_verbs = 1;
2990                 spec->init_verbs[0] = ad1988_6stack_init_verbs;
2991                 if (board_config == AD1988_6STACK_DIG) {
2992                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
2993                         spec->dig_in_nid = AD1988_SPDIF_IN;
2994                 }
2995                 break;
2996         case AD1988_3STACK:
2997         case AD1988_3STACK_DIG:
2998                 spec->multiout.max_channels = 6;
2999                 spec->multiout.num_dacs = 3;
3000                 if (is_rev2(codec))
3001                         spec->multiout.dac_nids = ad1988_3stack_dac_nids_rev2;
3002                 else
3003                         spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3004                 spec->input_mux = &ad1988_6stack_capture_source;
3005                 spec->channel_mode = ad1988_3stack_modes;
3006                 spec->num_channel_mode = ARRAY_SIZE(ad1988_3stack_modes);
3007                 spec->num_mixers = 2;
3008                 if (is_rev2(codec))
3009                         spec->mixers[0] = ad1988_3stack_mixers1_rev2;
3010                 else
3011                         spec->mixers[0] = ad1988_3stack_mixers1;
3012                 spec->mixers[1] = ad1988_3stack_mixers2;
3013                 spec->num_init_verbs = 1;
3014                 spec->init_verbs[0] = ad1988_3stack_init_verbs;
3015                 if (board_config == AD1988_3STACK_DIG)
3016                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3017                 break;
3018         case AD1988_LAPTOP:
3019         case AD1988_LAPTOP_DIG:
3020                 spec->multiout.max_channels = 2;
3021                 spec->multiout.num_dacs = 1;
3022                 spec->multiout.dac_nids = ad1988_3stack_dac_nids;
3023                 spec->input_mux = &ad1988_laptop_capture_source;
3024                 spec->num_mixers = 1;
3025                 spec->mixers[0] = ad1988_laptop_mixers;
3026                 spec->num_init_verbs = 1;
3027                 spec->init_verbs[0] = ad1988_laptop_init_verbs;
3028                 if (board_config == AD1988_LAPTOP_DIG)
3029                         spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3030                 break;
3031         }
3032
3033         spec->num_adc_nids = ARRAY_SIZE(ad1988_adc_nids);
3034         spec->adc_nids = ad1988_adc_nids;
3035         spec->capsrc_nids = ad1988_capsrc_nids;
3036         spec->mixers[spec->num_mixers++] = ad1988_capture_mixers;
3037         spec->init_verbs[spec->num_init_verbs++] = ad1988_capture_init_verbs;
3038         if (spec->multiout.dig_out_nid) {
3039                 if (codec->vendor_id >= 0x11d4989a) {
3040                         spec->mixers[spec->num_mixers++] =
3041                                 ad1989_spdif_out_mixers;
3042                         spec->init_verbs[spec->num_init_verbs++] =
3043                                 ad1989_spdif_init_verbs;
3044                         codec->slave_dig_outs = ad1989b_slave_dig_outs;
3045                 } else {
3046                         spec->mixers[spec->num_mixers++] =
3047                                 ad1988_spdif_out_mixers;
3048                         spec->init_verbs[spec->num_init_verbs++] =
3049                                 ad1988_spdif_init_verbs;
3050                 }
3051         }
3052         if (spec->dig_in_nid && codec->vendor_id < 0x11d4989a)
3053                 spec->mixers[spec->num_mixers++] = ad1988_spdif_in_mixers;
3054
3055         codec->patch_ops = ad198x_patch_ops;
3056         switch (board_config) {
3057         case AD1988_AUTO:
3058                 codec->patch_ops.init = ad1988_auto_init;
3059                 break;
3060         case AD1988_LAPTOP:
3061         case AD1988_LAPTOP_DIG:
3062                 codec->patch_ops.unsol_event = ad1988_laptop_unsol_event;
3063                 break;
3064         }
3065 #ifdef CONFIG_SND_HDA_POWER_SAVE
3066         spec->loopback.amplist = ad1988_loopbacks;
3067 #endif
3068         spec->vmaster_nid = 0x04;
3069
3070         return 0;
3071 }
3072
3073
3074 /*
3075  * AD1884 / AD1984
3076  *
3077  * port-B - front line/mic-in
3078  * port-E - aux in/out
3079  * port-F - aux in/out
3080  * port-C - rear line/mic-in
3081  * port-D - rear line/hp-out
3082  * port-A - front line/hp-out
3083  *
3084  * AD1984 = AD1884 + two digital mic-ins
3085  *
3086  * FIXME:
3087  * For simplicity, we share the single DAC for both HP and line-outs
3088  * right now.  The inidividual playbacks could be easily implemented,
3089  * but no build-up framework is given, so far.
3090  */
3091
3092 static hda_nid_t ad1884_dac_nids[1] = {
3093         0x04,
3094 };
3095
3096 static hda_nid_t ad1884_adc_nids[2] = {
3097         0x08, 0x09,
3098 };
3099
3100 static hda_nid_t ad1884_capsrc_nids[2] = {
3101         0x0c, 0x0d,
3102 };
3103
3104 #define AD1884_SPDIF_OUT        0x02
3105
3106 static struct hda_input_mux ad1884_capture_source = {
3107         .num_items = 4,
3108         .items = {
3109                 { "Front Mic", 0x0 },
3110                 { "Mic", 0x1 },
3111                 { "CD", 0x2 },
3112                 { "Mix", 0x3 },
3113         },
3114 };
3115
3116 static struct snd_kcontrol_new ad1884_base_mixers[] = {
3117         HDA_CODEC_VOLUME("PCM Playback Volume", 0x04, 0x0, HDA_OUTPUT),
3118         /* HDA_CODEC_VOLUME_IDX("PCM Playback Volume", 1, 0x03, 0x0, HDA_OUTPUT), */
3119         HDA_CODEC_MUTE("Headphone Playback Switch", 0x11, 0x0, HDA_OUTPUT),
3120         HDA_CODEC_MUTE("Front Playback Switch", 0x12, 0x0, HDA_OUTPUT),
3121         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
3122         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
3123         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
3124         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3125         HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x01, HDA_INPUT),
3126         HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3127         HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3128         HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3129         /*
3130         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x20, 0x03, HDA_INPUT),
3131         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x20, 0x03, HDA_INPUT),
3132         HDA_CODEC_VOLUME("Digital Beep Playback Volume", 0x10, 0x0, HDA_OUTPUT),
3133         HDA_CODEC_MUTE("Digital Beep Playback Switch", 0x10, 0x0, HDA_OUTPUT),
3134         */
3135         HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3136         HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3137         HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3138         HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3139         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3140         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x0d, 0x0, HDA_OUTPUT),
3141         {
3142                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3143                 /* The multiple "Capture Source" controls confuse alsamixer
3144                  * So call somewhat different..
3145                  */
3146                 /* .name = "Capture Source", */
3147                 .name = "Input Source",
3148                 .count = 2,
3149                 .info = ad198x_mux_enum_info,
3150                 .get = ad198x_mux_enum_get,
3151                 .put = ad198x_mux_enum_put,
3152         },
3153         /* SPDIF controls */
3154         HDA_CODEC_VOLUME("IEC958 Playback Volume", 0x1b, 0x0, HDA_OUTPUT),
3155         {
3156                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3157                 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,NONE) "Source",
3158                 /* identical with ad1983 */
3159                 .info = ad1983_spdif_route_info,
3160                 .get = ad1983_spdif_route_get,
3161                 .put = ad1983_spdif_route_put,
3162         },
3163         { } /* end */
3164 };
3165
3166 static struct snd_kcontrol_new ad1984_dmic_mixers[] = {
3167         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x05, 0x0, HDA_INPUT),
3168         HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x05, 0x0, HDA_INPUT),
3169         HDA_CODEC_VOLUME_IDX("Digital Mic Capture Volume", 1, 0x06, 0x0,
3170                              HDA_INPUT),
3171         HDA_CODEC_MUTE_IDX("Digital Mic Capture Switch", 1, 0x06, 0x0,
3172                            HDA_INPUT),
3173         { } /* end */
3174 };
3175
3176 /*
3177  * initialization verbs
3178  */
3179 static struct hda_verb ad1884_init_verbs[] = {
3180         /* DACs; mute as default */
3181         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3182         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3183         /* Port-A (HP) mixer */
3184         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3185         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3186         /* Port-A pin */
3187         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3188         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3189         /* HP selector - select DAC2 */
3190         {0x22, AC_VERB_SET_CONNECT_SEL, 0x1},
3191         /* Port-D (Line-out) mixer */
3192         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3193         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3194         /* Port-D pin */
3195         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3196         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3197         /* Mono-out mixer */
3198         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3199         {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3200         /* Mono-out pin */
3201         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3202         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3203         /* Mono selector */
3204         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x1},
3205         /* Port-B (front mic) pin */
3206         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3207         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3208         /* Port-C (rear mic) pin */
3209         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3210         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3211         /* Analog mixer; mute as default */
3212         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3213         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3214         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3215         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3216         /* Analog Mix output amp */
3217         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
3218         /* SPDIF output selector */
3219         {0x02, AC_VERB_SET_CONNECT_SEL, 0x0}, /* PCM */
3220         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x27}, /* 0dB */
3221         { } /* end */
3222 };
3223
3224 #ifdef CONFIG_SND_HDA_POWER_SAVE
3225 static struct hda_amp_list ad1884_loopbacks[] = {
3226         { 0x20, HDA_INPUT, 0 }, /* Front Mic */
3227         { 0x20, HDA_INPUT, 1 }, /* Mic */
3228         { 0x20, HDA_INPUT, 2 }, /* CD */
3229         { 0x20, HDA_INPUT, 4 }, /* Docking */
3230         { } /* end */
3231 };
3232 #endif
3233
3234 static const char *ad1884_slave_vols[] = {
3235         "PCM Playback Volume",
3236         "Mic Playback Volume",
3237         "Mono Playback Volume",
3238         "Front Mic Playback Volume",
3239         "Mic Playback Volume",