ALSA: hda - Fix jack-detection control of VT1708
[pandora-kernel.git] / sound / pci / hda / patch_via.c
1 /*
2  * Universal Interface for Intel High Definition Audio Codec
3  *
4  * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
5  *
6  *  (C) 2006-2009 VIA Technology, Inc.
7  *  (C) 2006-2008 Takashi Iwai <tiwai@suse.de>
8  *
9  *  This driver is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This driver is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
22  */
23
24 /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
25 /*                                                                           */
26 /* 2006-03-03  Lydia Wang  Create the basic patch to support VT1708 codec    */
27 /* 2006-03-14  Lydia Wang  Modify hard code for some pin widget nid          */
28 /* 2006-08-02  Lydia Wang  Add support to VT1709 codec                       */
29 /* 2006-09-08  Lydia Wang  Fix internal loopback recording source select bug */
30 /* 2007-09-12  Lydia Wang  Add EAPD enable during driver initialization      */
31 /* 2007-09-17  Lydia Wang  Add VT1708B codec support                        */
32 /* 2007-11-14  Lydia Wang  Add VT1708A codec HP and CD pin connect config    */
33 /* 2008-02-03  Lydia Wang  Fix Rear channels and Back channels inverse issue */
34 /* 2008-03-06  Lydia Wang  Add VT1702 codec and VT1708S codec support        */
35 /* 2008-04-09  Lydia Wang  Add mute front speaker when HP plugin             */
36 /* 2008-04-09  Lydia Wang  Add Independent HP feature                        */
37 /* 2008-05-28  Lydia Wang  Add second S/PDIF Out support for VT1702          */
38 /* 2008-09-15  Logan Li    Add VT1708S Mic Boost workaround/backdoor         */
39 /* 2009-02-16  Logan Li    Add support for VT1718S                           */
40 /* 2009-03-13  Logan Li    Add support for VT1716S                           */
41 /* 2009-04-14  Lydai Wang  Add support for VT1828S and VT2020                */
42 /* 2009-07-08  Lydia Wang  Add support for VT2002P                           */
43 /* 2009-07-21  Lydia Wang  Add support for VT1812                            */
44 /* 2009-09-19  Lydia Wang  Add support for VT1818S                           */
45 /*                                                                           */
46 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
47
48
49 #include <linux/init.h>
50 #include <linux/delay.h>
51 #include <linux/slab.h>
52 #include <linux/module.h>
53 #include <sound/core.h>
54 #include <sound/asoundef.h>
55 #include "hda_codec.h"
56 #include "hda_local.h"
57
58 /* Pin Widget NID */
59 #define VT1708_HP_PIN_NID       0x20
60 #define VT1708_CD_PIN_NID       0x24
61
62 enum VIA_HDA_CODEC {
63         UNKNOWN = -1,
64         VT1708,
65         VT1709_10CH,
66         VT1709_6CH,
67         VT1708B_8CH,
68         VT1708B_4CH,
69         VT1708S,
70         VT1708BCE,
71         VT1702,
72         VT1718S,
73         VT1716S,
74         VT2002P,
75         VT1812,
76         VT1802,
77         CODEC_TYPES,
78 };
79
80 #define VT2002P_COMPATIBLE(spec) \
81         ((spec)->codec_type == VT2002P ||\
82          (spec)->codec_type == VT1812 ||\
83          (spec)->codec_type == VT1802)
84
85 #define MAX_NID_PATH_DEPTH      5
86
87 /* output-path: DAC -> ... -> pin
88  * idx[] contains the source index number of the next widget;
89  * e.g. idx[0] is the index of the DAC selected by path[1] widget
90  * multi[] indicates whether it's a selector widget with multi-connectors
91  * (i.e. the connection selection is mandatory)
92  * vol_ctl and mute_ctl contains the NIDs for the assigned mixers
93  */
94 struct nid_path {
95         int depth;
96         hda_nid_t path[MAX_NID_PATH_DEPTH];
97         unsigned char idx[MAX_NID_PATH_DEPTH];
98         unsigned char multi[MAX_NID_PATH_DEPTH];
99         unsigned int vol_ctl;
100         unsigned int mute_ctl;
101 };
102
103 /* input-path */
104 struct via_input {
105         hda_nid_t pin;  /* input-pin or aa-mix */
106         int adc_idx;    /* ADC index to be used */
107         int mux_idx;    /* MUX index (if any) */
108         const char *label;      /* input-source label */
109 };
110
111 #define VIA_MAX_ADCS    3
112
113 enum {
114         STREAM_MULTI_OUT = (1 << 0),
115         STREAM_INDEP_HP = (1 << 1),
116 };
117
118 struct via_spec {
119         /* codec parameterization */
120         const struct snd_kcontrol_new *mixers[6];
121         unsigned int num_mixers;
122
123         const struct hda_verb *init_verbs[5];
124         unsigned int num_iverbs;
125
126         char stream_name_analog[32];
127         char stream_name_hp[32];
128         const struct hda_pcm_stream *stream_analog_playback;
129         const struct hda_pcm_stream *stream_analog_capture;
130
131         char stream_name_digital[32];
132         const struct hda_pcm_stream *stream_digital_playback;
133         const struct hda_pcm_stream *stream_digital_capture;
134
135         /* playback */
136         struct hda_multi_out multiout;
137         hda_nid_t slave_dig_outs[2];
138         hda_nid_t hp_dac_nid;
139         hda_nid_t speaker_dac_nid;
140         int hp_indep_shared;    /* indep HP-DAC is shared with side ch */
141         int opened_streams;     /* STREAM_* bits */
142         int active_streams;     /* STREAM_* bits */
143         int aamix_mode;         /* loopback is enabled for output-path? */
144
145         /* Output-paths:
146          * There are different output-paths depending on the setup.
147          * out_path, hp_path and speaker_path are primary paths.  If both
148          * direct DAC and aa-loopback routes are available, these contain
149          * the former paths.  Meanwhile *_mix_path contain the paths with
150          * loopback mixer.  (Since the loopback is only for front channel,
151          * no out_mix_path for surround channels.)
152          * The HP output has another path, hp_indep_path, which is used in
153          * the independent-HP mode.
154          */
155         struct nid_path out_path[HDA_SIDE + 1];
156         struct nid_path out_mix_path;
157         struct nid_path hp_path;
158         struct nid_path hp_mix_path;
159         struct nid_path hp_indep_path;
160         struct nid_path speaker_path;
161         struct nid_path speaker_mix_path;
162
163         /* capture */
164         unsigned int num_adc_nids;
165         hda_nid_t adc_nids[VIA_MAX_ADCS];
166         hda_nid_t mux_nids[VIA_MAX_ADCS];
167         hda_nid_t aa_mix_nid;
168         hda_nid_t dig_in_nid;
169
170         /* capture source */
171         bool dyn_adc_switch;
172         int num_inputs;
173         struct via_input inputs[AUTO_CFG_MAX_INS + 1];
174         unsigned int cur_mux[VIA_MAX_ADCS];
175
176         /* dynamic DAC switching */
177         unsigned int cur_dac_stream_tag;
178         unsigned int cur_dac_format;
179         unsigned int cur_hp_stream_tag;
180         unsigned int cur_hp_format;
181
182         /* dynamic ADC switching */
183         hda_nid_t cur_adc;
184         unsigned int cur_adc_stream_tag;
185         unsigned int cur_adc_format;
186
187         /* PCM information */
188         struct hda_pcm pcm_rec[3];
189
190         /* dynamic controls, init_verbs and input_mux */
191         struct auto_pin_cfg autocfg;
192         struct snd_array kctls;
193         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
194
195         /* HP mode source */
196         unsigned int hp_independent_mode;
197         unsigned int dmic_enabled;
198         unsigned int no_pin_power_ctl;
199         enum VIA_HDA_CODEC codec_type;
200
201         /* smart51 setup */
202         unsigned int smart51_nums;
203         hda_nid_t smart51_pins[2];
204         int smart51_idxs[2];
205         const char *smart51_labels[2];
206         unsigned int smart51_enabled;
207
208         /* work to check hp jack state */
209         struct hda_codec *codec;
210         struct delayed_work vt1708_hp_work;
211         int hp_work_active;
212         int vt1708_jack_detect;
213         int vt1708_hp_present;
214
215         void (*set_widgets_power_state)(struct hda_codec *codec);
216
217         struct hda_loopback_check loopback;
218         int num_loopbacks;
219         struct hda_amp_list loopback_list[8];
220
221         /* bind capture-volume */
222         struct hda_bind_ctls *bind_cap_vol;
223         struct hda_bind_ctls *bind_cap_sw;
224
225         struct mutex config_mutex;
226 };
227
228 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
229 static struct via_spec * via_new_spec(struct hda_codec *codec)
230 {
231         struct via_spec *spec;
232
233         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
234         if (spec == NULL)
235                 return NULL;
236
237         mutex_init(&spec->config_mutex);
238         codec->spec = spec;
239         spec->codec = codec;
240         spec->codec_type = get_codec_type(codec);
241         /* VT1708BCE & VT1708S are almost same */
242         if (spec->codec_type == VT1708BCE)
243                 spec->codec_type = VT1708S;
244         return spec;
245 }
246
247 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
248 {
249         u32 vendor_id = codec->vendor_id;
250         u16 ven_id = vendor_id >> 16;
251         u16 dev_id = vendor_id & 0xffff;
252         enum VIA_HDA_CODEC codec_type;
253
254         /* get codec type */
255         if (ven_id != 0x1106)
256                 codec_type = UNKNOWN;
257         else if (dev_id >= 0x1708 && dev_id <= 0x170b)
258                 codec_type = VT1708;
259         else if (dev_id >= 0xe710 && dev_id <= 0xe713)
260                 codec_type = VT1709_10CH;
261         else if (dev_id >= 0xe714 && dev_id <= 0xe717)
262                 codec_type = VT1709_6CH;
263         else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
264                 codec_type = VT1708B_8CH;
265                 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
266                         codec_type = VT1708BCE;
267         } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
268                 codec_type = VT1708B_4CH;
269         else if ((dev_id & 0xfff) == 0x397
270                  && (dev_id >> 12) < 8)
271                 codec_type = VT1708S;
272         else if ((dev_id & 0xfff) == 0x398
273                  && (dev_id >> 12) < 8)
274                 codec_type = VT1702;
275         else if ((dev_id & 0xfff) == 0x428
276                  && (dev_id >> 12) < 8)
277                 codec_type = VT1718S;
278         else if (dev_id == 0x0433 || dev_id == 0xa721)
279                 codec_type = VT1716S;
280         else if (dev_id == 0x0441 || dev_id == 0x4441)
281                 codec_type = VT1718S;
282         else if (dev_id == 0x0438 || dev_id == 0x4438)
283                 codec_type = VT2002P;
284         else if (dev_id == 0x0448)
285                 codec_type = VT1812;
286         else if (dev_id == 0x0440)
287                 codec_type = VT1708S;
288         else if ((dev_id & 0xfff) == 0x446)
289                 codec_type = VT1802;
290         else
291                 codec_type = UNKNOWN;
292         return codec_type;
293 };
294
295 #define VIA_JACK_EVENT          0x20
296 #define VIA_HP_EVENT            0x01
297 #define VIA_GPIO_EVENT          0x02
298 #define VIA_LINE_EVENT          0x03
299
300 enum {
301         VIA_CTL_WIDGET_VOL,
302         VIA_CTL_WIDGET_MUTE,
303         VIA_CTL_WIDGET_ANALOG_MUTE,
304 };
305
306 static void analog_low_current_mode(struct hda_codec *codec);
307 static bool is_aa_path_mute(struct hda_codec *codec);
308
309 #define hp_detect_with_aa(codec) \
310         (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1 && \
311          !is_aa_path_mute(codec))
312
313 static void vt1708_stop_hp_work(struct via_spec *spec)
314 {
315         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
316                 return;
317         if (spec->hp_work_active) {
318                 snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 1);
319                 cancel_delayed_work_sync(&spec->vt1708_hp_work);
320                 spec->hp_work_active = 0;
321         }
322 }
323
324 static void vt1708_update_hp_work(struct via_spec *spec)
325 {
326         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
327                 return;
328         if (spec->vt1708_jack_detect &&
329             (spec->active_streams || hp_detect_with_aa(spec->codec))) {
330                 if (!spec->hp_work_active) {
331                         snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81, 0);
332                         schedule_delayed_work(&spec->vt1708_hp_work,
333                                               msecs_to_jiffies(100));
334                         spec->hp_work_active = 1;
335                 }
336         } else if (!hp_detect_with_aa(spec->codec))
337                 vt1708_stop_hp_work(spec);
338 }
339
340 static void set_widgets_power_state(struct hda_codec *codec)
341 {
342         struct via_spec *spec = codec->spec;
343         if (spec->set_widgets_power_state)
344                 spec->set_widgets_power_state(codec);
345 }
346
347 static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
348                                    struct snd_ctl_elem_value *ucontrol)
349 {
350         int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
351         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
352
353         set_widgets_power_state(codec);
354         analog_low_current_mode(snd_kcontrol_chip(kcontrol));
355         vt1708_update_hp_work(codec->spec);
356         return change;
357 }
358
359 /* modify .put = snd_hda_mixer_amp_switch_put */
360 #define ANALOG_INPUT_MUTE                                               \
361         {               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
362                         .name = NULL,                                   \
363                         .index = 0,                                     \
364                         .info = snd_hda_mixer_amp_switch_info,          \
365                         .get = snd_hda_mixer_amp_switch_get,            \
366                         .put = analog_input_switch_put,                 \
367                         .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
368
369 static const struct snd_kcontrol_new via_control_templates[] = {
370         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
371         HDA_CODEC_MUTE(NULL, 0, 0, 0),
372         ANALOG_INPUT_MUTE,
373 };
374
375
376 /* add dynamic controls */
377 static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec,
378                                 const struct snd_kcontrol_new *tmpl,
379                                 const char *name)
380 {
381         struct snd_kcontrol_new *knew;
382
383         snd_array_init(&spec->kctls, sizeof(*knew), 32);
384         knew = snd_array_new(&spec->kctls);
385         if (!knew)
386                 return NULL;
387         *knew = *tmpl;
388         if (!name)
389                 name = tmpl->name;
390         if (name) {
391                 knew->name = kstrdup(name, GFP_KERNEL);
392                 if (!knew->name)
393                         return NULL;
394         }
395         return knew;
396 }
397
398 static int __via_add_control(struct via_spec *spec, int type, const char *name,
399                              int idx, unsigned long val)
400 {
401         struct snd_kcontrol_new *knew;
402
403         knew = __via_clone_ctl(spec, &via_control_templates[type], name);
404         if (!knew)
405                 return -ENOMEM;
406         knew->index = idx;
407         if (get_amp_nid_(val))
408                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
409         knew->private_value = val;
410         return 0;
411 }
412
413 #define via_add_control(spec, type, name, val) \
414         __via_add_control(spec, type, name, 0, val)
415
416 #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL)
417
418 static void via_free_kctls(struct hda_codec *codec)
419 {
420         struct via_spec *spec = codec->spec;
421
422         if (spec->kctls.list) {
423                 struct snd_kcontrol_new *kctl = spec->kctls.list;
424                 int i;
425                 for (i = 0; i < spec->kctls.used; i++)
426                         kfree(kctl[i].name);
427         }
428         snd_array_free(&spec->kctls);
429 }
430
431 /* create input playback/capture controls for the given pin */
432 static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
433                                 int type_idx, int idx, int mix_nid)
434 {
435         char name[32];
436         int err;
437
438         sprintf(name, "%s Playback Volume", ctlname);
439         err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx,
440                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
441         if (err < 0)
442                 return err;
443         sprintf(name, "%s Playback Switch", ctlname);
444         err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx,
445                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
446         if (err < 0)
447                 return err;
448         return 0;
449 }
450
451 #define get_connection_index(codec, mux, nid) \
452         snd_hda_get_conn_index(codec, mux, nid, 0)
453
454 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
455                            unsigned int mask)
456 {
457         unsigned int caps;
458         if (!nid)
459                 return false;
460         caps = get_wcaps(codec, nid);
461         if (dir == HDA_INPUT)
462                 caps &= AC_WCAP_IN_AMP;
463         else
464                 caps &= AC_WCAP_OUT_AMP;
465         if (!caps)
466                 return false;
467         if (query_amp_caps(codec, nid, dir) & mask)
468                 return true;
469         return false;
470 }
471
472 #define have_mute(codec, nid, dir) \
473         check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
474
475 /* enable/disable the output-route mixers */
476 static void activate_output_mix(struct hda_codec *codec, struct nid_path *path,
477                                 hda_nid_t mix_nid, int idx, bool enable)
478 {
479         int i, num, val;
480
481         if (!path)
482                 return;
483         num = snd_hda_get_conn_list(codec, mix_nid, NULL);
484         for (i = 0; i < num; i++) {
485                 if (i == idx)
486                         val = AMP_IN_UNMUTE(i);
487                 else
488                         val = AMP_IN_MUTE(i);
489                 snd_hda_codec_write(codec, mix_nid, 0,
490                                     AC_VERB_SET_AMP_GAIN_MUTE, val);
491         }
492 }
493
494 /* enable/disable the output-route */
495 static void activate_output_path(struct hda_codec *codec, struct nid_path *path,
496                                  bool enable, bool force)
497 {
498         struct via_spec *spec = codec->spec;
499         int i;
500         for (i = 0; i < path->depth; i++) {
501                 hda_nid_t src, dst;
502                 int idx = path->idx[i];
503                 src = path->path[i];                    
504                 if (i < path->depth - 1)
505                         dst = path->path[i + 1];
506                 else
507                         dst = 0;
508                 if (enable && path->multi[i])
509                         snd_hda_codec_write(codec, dst, 0,
510                                             AC_VERB_SET_CONNECT_SEL, idx);
511                 if (!force && (dst == spec->aa_mix_nid))
512                         continue;
513                 if (have_mute(codec, dst, HDA_INPUT))
514                         activate_output_mix(codec, path, dst, idx, enable);
515                 if (!force && (src == path->vol_ctl || src == path->mute_ctl))
516                         continue;
517                 if (have_mute(codec, src, HDA_OUTPUT)) {
518                         int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE;
519                         snd_hda_codec_write(codec, src, 0,
520                                             AC_VERB_SET_AMP_GAIN_MUTE, val);
521                 }
522         }
523 }
524
525 /* set the given pin as output */
526 static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
527                             int pin_type)
528 {
529         if (!pin)
530                 return;
531         snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
532                             pin_type);
533         if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
534                 snd_hda_codec_write(codec, pin, 0,
535                                     AC_VERB_SET_EAPD_BTLENABLE, 0x02);
536 }
537
538 static void via_auto_init_output(struct hda_codec *codec,
539                                  struct nid_path *path, int pin_type)
540 {
541         unsigned int caps;
542         hda_nid_t pin;
543
544         if (!path->depth)
545                 return;
546         pin = path->path[path->depth - 1];
547
548         init_output_pin(codec, pin, pin_type);
549         caps = query_amp_caps(codec, pin, HDA_OUTPUT);
550         if (caps & AC_AMPCAP_MUTE) {
551                 unsigned int val;
552                 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
553                 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
554                                     AMP_OUT_MUTE | val);
555         }
556         activate_output_path(codec, path, true, true); /* force on */
557 }
558
559 static void via_auto_init_multi_out(struct hda_codec *codec)
560 {
561         struct via_spec *spec = codec->spec;
562         struct nid_path *path;
563         int i;
564
565         for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++) {
566                 path = &spec->out_path[i];
567                 if (!i && spec->aamix_mode && spec->out_mix_path.depth)
568                         path = &spec->out_mix_path;
569                 via_auto_init_output(codec, path, PIN_OUT);
570         }
571 }
572
573 /* deactivate the inactive headphone-paths */
574 static void deactivate_hp_paths(struct hda_codec *codec)
575 {
576         struct via_spec *spec = codec->spec;
577         int shared = spec->hp_indep_shared;
578
579         if (spec->hp_independent_mode) {
580                 activate_output_path(codec, &spec->hp_path, false, false);
581                 activate_output_path(codec, &spec->hp_mix_path, false, false);
582                 if (shared)
583                         activate_output_path(codec, &spec->out_path[shared],
584                                              false, false);
585         } else if (spec->aamix_mode || !spec->hp_path.depth) {
586                 activate_output_path(codec, &spec->hp_indep_path, false, false);
587                 activate_output_path(codec, &spec->hp_path, false, false);
588         } else {
589                 activate_output_path(codec, &spec->hp_indep_path, false, false);
590                 activate_output_path(codec, &spec->hp_mix_path, false, false);
591         }
592 }
593
594 static void via_auto_init_hp_out(struct hda_codec *codec)
595 {
596         struct via_spec *spec = codec->spec;
597
598         if (!spec->hp_path.depth) {
599                 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP);
600                 return;
601         }
602         deactivate_hp_paths(codec);
603         if (spec->hp_independent_mode)
604                 via_auto_init_output(codec, &spec->hp_indep_path, PIN_HP);
605         else if (spec->aamix_mode)
606                 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP);
607         else
608                 via_auto_init_output(codec, &spec->hp_path, PIN_HP);
609 }
610
611 static void via_auto_init_speaker_out(struct hda_codec *codec)
612 {
613         struct via_spec *spec = codec->spec;
614
615         if (!spec->autocfg.speaker_outs)
616                 return;
617         if (!spec->speaker_path.depth) {
618                 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT);
619                 return;
620         }
621         if (!spec->aamix_mode) {
622                 activate_output_path(codec, &spec->speaker_mix_path,
623                                      false, false);
624                 via_auto_init_output(codec, &spec->speaker_path, PIN_OUT);
625         } else {
626                 activate_output_path(codec, &spec->speaker_path, false, false);
627                 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT);
628         }
629 }
630
631 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin);
632 static void via_hp_automute(struct hda_codec *codec);
633
634 static void via_auto_init_analog_input(struct hda_codec *codec)
635 {
636         struct via_spec *spec = codec->spec;
637         const struct auto_pin_cfg *cfg = &spec->autocfg;
638         hda_nid_t conn[HDA_MAX_CONNECTIONS];
639         unsigned int ctl;
640         int i, num_conns;
641
642         /* init ADCs */
643         for (i = 0; i < spec->num_adc_nids; i++) {
644                 snd_hda_codec_write(codec, spec->adc_nids[i], 0,
645                                     AC_VERB_SET_AMP_GAIN_MUTE,
646                                     AMP_IN_UNMUTE(0));
647         }
648
649         /* init pins */
650         for (i = 0; i < cfg->num_inputs; i++) {
651                 hda_nid_t nid = cfg->inputs[i].pin;
652                 if (spec->smart51_enabled && is_smart51_pins(codec, nid))
653                         ctl = PIN_OUT;
654                 else if (cfg->inputs[i].type == AUTO_PIN_MIC)
655                         ctl = PIN_VREF50;
656                 else
657                         ctl = PIN_IN;
658                 snd_hda_codec_write(codec, nid, 0,
659                                     AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
660         }
661
662         /* init input-src */
663         for (i = 0; i < spec->num_adc_nids; i++) {
664                 int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx;
665                 if (spec->mux_nids[adc_idx]) {
666                         int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx;
667                         snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
668                                             AC_VERB_SET_CONNECT_SEL,
669                                             mux_idx);
670                 }
671                 if (spec->dyn_adc_switch)
672                         break; /* only one input-src */
673         }
674
675         /* init aa-mixer */
676         if (!spec->aa_mix_nid)
677                 return;
678         num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
679                                             ARRAY_SIZE(conn));
680         for (i = 0; i < num_conns; i++) {
681                 unsigned int caps = get_wcaps(codec, conn[i]);
682                 if (get_wcaps_type(caps) == AC_WID_PIN)
683                         snd_hda_codec_write(codec, spec->aa_mix_nid, 0,
684                                             AC_VERB_SET_AMP_GAIN_MUTE,
685                                             AMP_IN_MUTE(i));
686         }
687 }
688
689 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
690                                 unsigned int *affected_parm)
691 {
692         unsigned parm;
693         unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
694         unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
695                 >> AC_DEFCFG_MISC_SHIFT
696                 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
697         struct via_spec *spec = codec->spec;
698         unsigned present = 0;
699
700         no_presence |= spec->no_pin_power_ctl;
701         if (!no_presence)
702                 present = snd_hda_jack_detect(codec, nid);
703         if ((spec->smart51_enabled && is_smart51_pins(codec, nid))
704             || ((no_presence || present)
705                 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
706                 *affected_parm = AC_PWRST_D0; /* if it's connected */
707                 parm = AC_PWRST_D0;
708         } else
709                 parm = AC_PWRST_D3;
710
711         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
712 }
713
714 static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
715                                   struct snd_ctl_elem_info *uinfo)
716 {
717         static const char * const texts[] = {
718                 "Disabled", "Enabled"
719         };
720
721         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
722         uinfo->count = 1;
723         uinfo->value.enumerated.items = 2;
724         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
725                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
726         strcpy(uinfo->value.enumerated.name,
727                texts[uinfo->value.enumerated.item]);
728         return 0;
729 }
730
731 static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
732                                  struct snd_ctl_elem_value *ucontrol)
733 {
734         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
735         struct via_spec *spec = codec->spec;
736         ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
737         return 0;
738 }
739
740 static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
741                                  struct snd_ctl_elem_value *ucontrol)
742 {
743         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
744         struct via_spec *spec = codec->spec;
745         unsigned int val = !ucontrol->value.enumerated.item[0];
746
747         if (val == spec->no_pin_power_ctl)
748                 return 0;
749         spec->no_pin_power_ctl = val;
750         set_widgets_power_state(codec);
751         return 1;
752 }
753
754 static const struct snd_kcontrol_new via_pin_power_ctl_enum = {
755         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
756         .name = "Dynamic Power-Control",
757         .info = via_pin_power_ctl_info,
758         .get = via_pin_power_ctl_get,
759         .put = via_pin_power_ctl_put,
760 };
761
762
763 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
764                                    struct snd_ctl_elem_info *uinfo)
765 {
766         static const char * const texts[] = { "OFF", "ON" };
767
768         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
769         uinfo->count = 1;
770         uinfo->value.enumerated.items = 2;
771         if (uinfo->value.enumerated.item >= 2)
772                 uinfo->value.enumerated.item = 1;
773         strcpy(uinfo->value.enumerated.name,
774                texts[uinfo->value.enumerated.item]);
775         return 0;
776 }
777
778 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
779                                   struct snd_ctl_elem_value *ucontrol)
780 {
781         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
782         struct via_spec *spec = codec->spec;
783
784         ucontrol->value.enumerated.item[0] = spec->hp_independent_mode;
785         return 0;
786 }
787
788 /* adjust spec->multiout setup according to the current flags */
789 static void setup_playback_multi_pcm(struct via_spec *spec)
790 {
791         const struct auto_pin_cfg *cfg = &spec->autocfg;
792         spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
793         spec->multiout.hp_nid = 0;
794         if (!spec->hp_independent_mode) {
795                 if (!spec->hp_indep_shared)
796                         spec->multiout.hp_nid = spec->hp_dac_nid;
797         } else {
798                 if (spec->hp_indep_shared)
799                         spec->multiout.num_dacs = cfg->line_outs - 1;
800         }
801 }
802
803 /* update DAC setups according to indep-HP switch;
804  * this function is called only when indep-HP is modified
805  */
806 static void switch_indep_hp_dacs(struct hda_codec *codec)
807 {
808         struct via_spec *spec = codec->spec;
809         int shared = spec->hp_indep_shared;
810         hda_nid_t shared_dac, hp_dac;
811
812         if (!spec->opened_streams)
813                 return;
814
815         shared_dac = shared ? spec->multiout.dac_nids[shared] : 0;
816         hp_dac = spec->hp_dac_nid;
817         if (spec->hp_independent_mode) {
818                 /* switch to indep-HP mode */
819                 if (spec->active_streams & STREAM_MULTI_OUT) {
820                         __snd_hda_codec_cleanup_stream(codec, hp_dac, 1);
821                         __snd_hda_codec_cleanup_stream(codec, shared_dac, 1);
822                 }
823                 if (spec->active_streams & STREAM_INDEP_HP)
824                         snd_hda_codec_setup_stream(codec, hp_dac,
825                                                    spec->cur_hp_stream_tag, 0,
826                                                    spec->cur_hp_format);
827         } else {
828                 /* back to HP or shared-DAC */
829                 if (spec->active_streams & STREAM_INDEP_HP)
830                         __snd_hda_codec_cleanup_stream(codec, hp_dac, 1);
831                 if (spec->active_streams & STREAM_MULTI_OUT) {
832                         hda_nid_t dac;
833                         int ch;
834                         if (shared_dac) { /* reset mutli-ch DAC */
835                                 dac = shared_dac;
836                                 ch = shared * 2;
837                         } else { /* reset HP DAC */
838                                 dac = hp_dac;
839                                 ch = 0;
840                         }
841                         snd_hda_codec_setup_stream(codec, dac,
842                                                    spec->cur_dac_stream_tag, ch,
843                                                    spec->cur_dac_format);
844                 }
845         }
846         setup_playback_multi_pcm(spec);
847 }
848
849 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
850                                   struct snd_ctl_elem_value *ucontrol)
851 {
852         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
853         struct via_spec *spec = codec->spec;
854         int cur, shared;
855
856         mutex_lock(&spec->config_mutex);
857         cur = !!ucontrol->value.enumerated.item[0];
858         if (spec->hp_independent_mode == cur) {
859                 mutex_unlock(&spec->config_mutex);
860                 return 0;
861         }
862         spec->hp_independent_mode = cur;
863         shared = spec->hp_indep_shared;
864         deactivate_hp_paths(codec);
865         if (cur)
866                 activate_output_path(codec, &spec->hp_indep_path, true, false);
867         else {
868                 if (shared)
869                         activate_output_path(codec, &spec->out_path[shared],
870                                              true, false);
871                 if (spec->aamix_mode || !spec->hp_path.depth)
872                         activate_output_path(codec, &spec->hp_mix_path,
873                                              true, false);
874                 else
875                         activate_output_path(codec, &spec->hp_path,
876                                              true, false);
877         }
878
879         switch_indep_hp_dacs(codec);
880         mutex_unlock(&spec->config_mutex);
881
882         /* update jack power state */
883         set_widgets_power_state(codec);
884         via_hp_automute(codec);
885         return 1;
886 }
887
888 static const struct snd_kcontrol_new via_hp_mixer = {
889         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
890         .name = "Independent HP",
891         .info = via_independent_hp_info,
892         .get = via_independent_hp_get,
893         .put = via_independent_hp_put,
894 };
895
896 static int via_hp_build(struct hda_codec *codec)
897 {
898         struct via_spec *spec = codec->spec;
899         struct snd_kcontrol_new *knew;
900         hda_nid_t nid;
901
902         nid = spec->autocfg.hp_pins[0];
903         knew = via_clone_control(spec, &via_hp_mixer);
904         if (knew == NULL)
905                 return -ENOMEM;
906
907         knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
908
909         return 0;
910 }
911
912 static void notify_aa_path_ctls(struct hda_codec *codec)
913 {
914         struct via_spec *spec = codec->spec;
915         int i;
916
917         for (i = 0; i < spec->smart51_nums; i++) {
918                 struct snd_kcontrol *ctl;
919                 struct snd_ctl_elem_id id;
920                 memset(&id, 0, sizeof(id));
921                 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
922                 sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]);
923                 ctl = snd_hda_find_mixer_ctl(codec, id.name);
924                 if (ctl)
925                         snd_ctl_notify(codec->bus->card,
926                                         SNDRV_CTL_EVENT_MASK_VALUE,
927                                         &ctl->id);
928         }
929 }
930
931 static void mute_aa_path(struct hda_codec *codec, int mute)
932 {
933         struct via_spec *spec = codec->spec;
934         int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
935         int i;
936
937         /* check AA path's mute status */
938         for (i = 0; i < spec->smart51_nums; i++) {
939                 if (spec->smart51_idxs[i] < 0)
940                         continue;
941                 snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid,
942                                          HDA_INPUT, spec->smart51_idxs[i],
943                                          HDA_AMP_MUTE, val);
944         }
945 }
946
947 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
948 {
949         struct via_spec *spec = codec->spec;
950         int i;
951
952         for (i = 0; i < spec->smart51_nums; i++)
953                 if (spec->smart51_pins[i] == pin)
954                         return true;
955         return false;
956 }
957
958 static int via_smart51_get(struct snd_kcontrol *kcontrol,
959                            struct snd_ctl_elem_value *ucontrol)
960 {
961         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
962         struct via_spec *spec = codec->spec;
963
964         *ucontrol->value.integer.value = spec->smart51_enabled;
965         return 0;
966 }
967
968 static int via_smart51_put(struct snd_kcontrol *kcontrol,
969                            struct snd_ctl_elem_value *ucontrol)
970 {
971         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
972         struct via_spec *spec = codec->spec;
973         int out_in = *ucontrol->value.integer.value
974                 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
975         int i;
976
977         for (i = 0; i < spec->smart51_nums; i++) {
978                 hda_nid_t nid = spec->smart51_pins[i];
979                 unsigned int parm;
980
981                 parm = snd_hda_codec_read(codec, nid, 0,
982                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
983                 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
984                 parm |= out_in;
985                 snd_hda_codec_write(codec, nid, 0,
986                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
987                                     parm);
988                 if (out_in == AC_PINCTL_OUT_EN) {
989                         mute_aa_path(codec, 1);
990                         notify_aa_path_ctls(codec);
991                 }
992         }
993         spec->smart51_enabled = *ucontrol->value.integer.value;
994         set_widgets_power_state(codec);
995         return 1;
996 }
997
998 static const struct snd_kcontrol_new via_smart51_mixer = {
999         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1000         .name = "Smart 5.1",
1001         .count = 1,
1002         .info = snd_ctl_boolean_mono_info,
1003         .get = via_smart51_get,
1004         .put = via_smart51_put,
1005 };
1006
1007 static int via_smart51_build(struct hda_codec *codec)
1008 {
1009         struct via_spec *spec = codec->spec;
1010
1011         if (!spec->smart51_nums)
1012                 return 0;
1013         if (!via_clone_control(spec, &via_smart51_mixer))
1014                 return -ENOMEM;
1015         return 0;
1016 }
1017
1018 /* check AA path's mute status */
1019 static bool is_aa_path_mute(struct hda_codec *codec)
1020 {
1021         struct via_spec *spec = codec->spec;
1022         const struct hda_amp_list *p;
1023         int i, ch, v;
1024
1025         for (i = 0; i < spec->num_loopbacks; i++) {
1026                 p = &spec->loopback_list[i];
1027                 for (ch = 0; ch < 2; ch++) {
1028                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
1029                                                    p->idx);
1030                         if (!(v & HDA_AMP_MUTE) && v > 0)
1031                                 return false;
1032                 }
1033         }
1034         return true;
1035 }
1036
1037 /* enter/exit analog low-current mode */
1038 static void analog_low_current_mode(struct hda_codec *codec)
1039 {
1040         struct via_spec *spec = codec->spec;
1041         bool enable;
1042         unsigned int verb, parm;
1043
1044         enable = is_aa_path_mute(codec) && (spec->opened_streams != 0);
1045
1046         /* decide low current mode's verb & parameter */
1047         switch (spec->codec_type) {
1048         case VT1708B_8CH:
1049         case VT1708B_4CH:
1050                 verb = 0xf70;
1051                 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
1052                 break;
1053         case VT1708S:
1054         case VT1718S:
1055         case VT1716S:
1056                 verb = 0xf73;
1057                 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
1058                 break;
1059         case VT1702:
1060                 verb = 0xf73;
1061                 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
1062                 break;
1063         case VT2002P:
1064         case VT1812:
1065         case VT1802:
1066                 verb = 0xf93;
1067                 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
1068                 break;
1069         default:
1070                 return;         /* other codecs are not supported */
1071         }
1072         /* send verb */
1073         snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
1074 }
1075
1076 /*
1077  * generic initialization of ADC, input mixers and output mixers
1078  */
1079 static const struct hda_verb vt1708_init_verbs[] = {
1080         /* power down jack detect function */
1081         {0x1, 0xf81, 0x1},
1082         { }
1083 };
1084
1085 static void set_stream_open(struct hda_codec *codec, int bit, bool active)
1086 {
1087         struct via_spec *spec = codec->spec;
1088
1089         if (active)
1090                 spec->opened_streams |= bit;
1091         else
1092                 spec->opened_streams &= ~bit;
1093         analog_low_current_mode(codec);
1094 }
1095
1096 static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo,
1097                                  struct hda_codec *codec,
1098                                  struct snd_pcm_substream *substream)
1099 {
1100         struct via_spec *spec = codec->spec;
1101         const struct auto_pin_cfg *cfg = &spec->autocfg;
1102         int err;
1103
1104         spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
1105         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1106         set_stream_open(codec, STREAM_MULTI_OUT, true);
1107         err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
1108                                             hinfo);
1109         if (err < 0) {
1110                 set_stream_open(codec, STREAM_MULTI_OUT, false);
1111                 return err;
1112         }
1113         return 0;
1114 }
1115
1116 static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo,
1117                                   struct hda_codec *codec,
1118                                   struct snd_pcm_substream *substream)
1119 {
1120         set_stream_open(codec, STREAM_MULTI_OUT, false);
1121         return 0;
1122 }
1123
1124 static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo,
1125                                     struct hda_codec *codec,
1126                                     struct snd_pcm_substream *substream)
1127 {
1128         struct via_spec *spec = codec->spec;
1129
1130         if (snd_BUG_ON(!spec->hp_dac_nid))
1131                 return -EINVAL;
1132         set_stream_open(codec, STREAM_INDEP_HP, true);
1133         return 0;
1134 }
1135
1136 static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo,
1137                                      struct hda_codec *codec,
1138                                      struct snd_pcm_substream *substream)
1139 {
1140         set_stream_open(codec, STREAM_INDEP_HP, false);
1141         return 0;
1142 }
1143
1144 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
1145                                           struct hda_codec *codec,
1146                                           unsigned int stream_tag,
1147                                           unsigned int format,
1148                                           struct snd_pcm_substream *substream)
1149 {
1150         struct via_spec *spec = codec->spec;
1151
1152         mutex_lock(&spec->config_mutex);
1153         setup_playback_multi_pcm(spec);
1154         snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1155                                          format, substream);
1156         /* remember for dynamic DAC switch with indep-HP */
1157         spec->active_streams |= STREAM_MULTI_OUT;
1158         spec->cur_dac_stream_tag = stream_tag;
1159         spec->cur_dac_format = format;
1160         mutex_unlock(&spec->config_mutex);
1161         vt1708_update_hp_work(spec);
1162         return 0;
1163 }
1164
1165 static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
1166                                        struct hda_codec *codec,
1167                                        unsigned int stream_tag,
1168                                        unsigned int format,
1169                                        struct snd_pcm_substream *substream)
1170 {
1171         struct via_spec *spec = codec->spec;
1172
1173         mutex_lock(&spec->config_mutex);
1174         if (spec->hp_independent_mode)
1175                 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid,
1176                                            stream_tag, 0, format);
1177         spec->active_streams |= STREAM_INDEP_HP;
1178         spec->cur_hp_stream_tag = stream_tag;
1179         spec->cur_hp_format = format;
1180         mutex_unlock(&spec->config_mutex);
1181         vt1708_update_hp_work(spec);
1182         return 0;
1183 }
1184
1185 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
1186                                     struct hda_codec *codec,
1187                                     struct snd_pcm_substream *substream)
1188 {
1189         struct via_spec *spec = codec->spec;
1190
1191         mutex_lock(&spec->config_mutex);
1192         snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1193         spec->active_streams &= ~STREAM_MULTI_OUT;
1194         mutex_unlock(&spec->config_mutex);
1195         vt1708_update_hp_work(spec);
1196         return 0;
1197 }
1198
1199 static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
1200                                        struct hda_codec *codec,
1201                                        struct snd_pcm_substream *substream)
1202 {
1203         struct via_spec *spec = codec->spec;
1204
1205         mutex_lock(&spec->config_mutex);
1206         if (spec->hp_independent_mode)
1207                 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
1208         spec->active_streams &= ~STREAM_INDEP_HP;
1209         mutex_unlock(&spec->config_mutex);
1210         vt1708_update_hp_work(spec);
1211         return 0;
1212 }
1213
1214 /*
1215  * Digital out
1216  */
1217 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1218                                      struct hda_codec *codec,
1219                                      struct snd_pcm_substream *substream)
1220 {
1221         struct via_spec *spec = codec->spec;
1222         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1223 }
1224
1225 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1226                                       struct hda_codec *codec,
1227                                       struct snd_pcm_substream *substream)
1228 {
1229         struct via_spec *spec = codec->spec;
1230         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1231 }
1232
1233 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1234                                         struct hda_codec *codec,
1235                                         unsigned int stream_tag,
1236                                         unsigned int format,
1237                                         struct snd_pcm_substream *substream)
1238 {
1239         struct via_spec *spec = codec->spec;
1240         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1241                                              stream_tag, format, substream);
1242 }
1243
1244 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1245                                         struct hda_codec *codec,
1246                                         struct snd_pcm_substream *substream)
1247 {
1248         struct via_spec *spec = codec->spec;
1249         snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1250         return 0;
1251 }
1252
1253 /*
1254  * Analog capture
1255  */
1256 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1257                                    struct hda_codec *codec,
1258                                    unsigned int stream_tag,
1259                                    unsigned int format,
1260                                    struct snd_pcm_substream *substream)
1261 {
1262         struct via_spec *spec = codec->spec;
1263
1264         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1265                                    stream_tag, 0, format);
1266         return 0;
1267 }
1268
1269 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1270                                    struct hda_codec *codec,
1271                                    struct snd_pcm_substream *substream)
1272 {
1273         struct via_spec *spec = codec->spec;
1274         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1275         return 0;
1276 }
1277
1278 /* analog capture with dynamic ADC switching */
1279 static int via_dyn_adc_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1280                                            struct hda_codec *codec,
1281                                            unsigned int stream_tag,
1282                                            unsigned int format,
1283                                            struct snd_pcm_substream *substream)
1284 {
1285         struct via_spec *spec = codec->spec;
1286         int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx;
1287
1288         mutex_lock(&spec->config_mutex);
1289         spec->cur_adc = spec->adc_nids[adc_idx];
1290         spec->cur_adc_stream_tag = stream_tag;
1291         spec->cur_adc_format = format;
1292         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
1293         mutex_unlock(&spec->config_mutex);
1294         return 0;
1295 }
1296
1297 static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1298                                            struct hda_codec *codec,
1299                                            struct snd_pcm_substream *substream)
1300 {
1301         struct via_spec *spec = codec->spec;
1302
1303         mutex_lock(&spec->config_mutex);
1304         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
1305         spec->cur_adc = 0;
1306         mutex_unlock(&spec->config_mutex);
1307         return 0;
1308 }
1309
1310 /* re-setup the stream if running; called from input-src put */
1311 static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
1312 {
1313         struct via_spec *spec = codec->spec;
1314         int adc_idx = spec->inputs[cur].adc_idx;
1315         hda_nid_t adc = spec->adc_nids[adc_idx];
1316         bool ret = false;
1317
1318         mutex_lock(&spec->config_mutex);
1319         if (spec->cur_adc && spec->cur_adc != adc) {
1320                 /* stream is running, let's swap the current ADC */
1321                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1322                 spec->cur_adc = adc;
1323                 snd_hda_codec_setup_stream(codec, adc,
1324                                            spec->cur_adc_stream_tag, 0,
1325                                            spec->cur_adc_format);
1326                 ret = true;
1327         }
1328         mutex_unlock(&spec->config_mutex);
1329         return ret;
1330 }
1331
1332 static const struct hda_pcm_stream via_pcm_analog_playback = {
1333         .substreams = 1,
1334         .channels_min = 2,
1335         .channels_max = 8,
1336         /* NID is set in via_build_pcms */
1337         .ops = {
1338                 .open = via_playback_multi_pcm_open,
1339                 .close = via_playback_multi_pcm_close,
1340                 .prepare = via_playback_multi_pcm_prepare,
1341                 .cleanup = via_playback_multi_pcm_cleanup
1342         },
1343 };
1344
1345 static const struct hda_pcm_stream via_pcm_hp_playback = {
1346         .substreams = 1,
1347         .channels_min = 2,
1348         .channels_max = 2,
1349         /* NID is set in via_build_pcms */
1350         .ops = {
1351                 .open = via_playback_hp_pcm_open,
1352                 .close = via_playback_hp_pcm_close,
1353                 .prepare = via_playback_hp_pcm_prepare,
1354                 .cleanup = via_playback_hp_pcm_cleanup
1355         },
1356 };
1357
1358 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1359         .substreams = 1,
1360         .channels_min = 2,
1361         .channels_max = 8,
1362         /* NID is set in via_build_pcms */
1363         /* We got noisy outputs on the right channel on VT1708 when
1364          * 24bit samples are used.  Until any workaround is found,
1365          * disable the 24bit format, so far.
1366          */
1367         .formats = SNDRV_PCM_FMTBIT_S16_LE,
1368         .ops = {
1369                 .open = via_playback_multi_pcm_open,
1370                 .close = via_playback_multi_pcm_close,
1371                 .prepare = via_playback_multi_pcm_prepare,
1372                 .cleanup = via_playback_multi_pcm_cleanup
1373         },
1374 };
1375
1376 static const struct hda_pcm_stream via_pcm_analog_capture = {
1377         .substreams = 1, /* will be changed in via_build_pcms() */
1378         .channels_min = 2,
1379         .channels_max = 2,
1380         /* NID is set in via_build_pcms */
1381         .ops = {
1382                 .prepare = via_capture_pcm_prepare,
1383                 .cleanup = via_capture_pcm_cleanup
1384         },
1385 };
1386
1387 static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = {
1388         .substreams = 1,
1389         .channels_min = 2,
1390         .channels_max = 2,
1391         /* NID is set in via_build_pcms */
1392         .ops = {
1393                 .prepare = via_dyn_adc_capture_pcm_prepare,
1394                 .cleanup = via_dyn_adc_capture_pcm_cleanup,
1395         },
1396 };
1397
1398 static const struct hda_pcm_stream via_pcm_digital_playback = {
1399         .substreams = 1,
1400         .channels_min = 2,
1401         .channels_max = 2,
1402         /* NID is set in via_build_pcms */
1403         .ops = {
1404                 .open = via_dig_playback_pcm_open,
1405                 .close = via_dig_playback_pcm_close,
1406                 .prepare = via_dig_playback_pcm_prepare,
1407                 .cleanup = via_dig_playback_pcm_cleanup
1408         },
1409 };
1410
1411 static const struct hda_pcm_stream via_pcm_digital_capture = {
1412         .substreams = 1,
1413         .channels_min = 2,
1414         .channels_max = 2,
1415 };
1416
1417 /*
1418  * slave controls for virtual master
1419  */
1420 static const char * const via_slave_vols[] = {
1421         "Front Playback Volume",
1422         "Surround Playback Volume",
1423         "Center Playback Volume",
1424         "LFE Playback Volume",
1425         "Side Playback Volume",
1426         "Headphone Playback Volume",
1427         "Speaker Playback Volume",
1428         NULL,
1429 };
1430
1431 static const char * const via_slave_sws[] = {
1432         "Front Playback Switch",
1433         "Surround Playback Switch",
1434         "Center Playback Switch",
1435         "LFE Playback Switch",
1436         "Side Playback Switch",
1437         "Headphone Playback Switch",
1438         "Speaker Playback Switch",
1439         NULL,
1440 };
1441
1442 static int via_build_controls(struct hda_codec *codec)
1443 {
1444         struct via_spec *spec = codec->spec;
1445         struct snd_kcontrol *kctl;
1446         int err, i;
1447
1448         if (spec->set_widgets_power_state)
1449                 if (!via_clone_control(spec, &via_pin_power_ctl_enum))
1450                         return -ENOMEM;
1451
1452         for (i = 0; i < spec->num_mixers; i++) {
1453                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1454                 if (err < 0)
1455                         return err;
1456         }
1457
1458         if (spec->multiout.dig_out_nid) {
1459                 err = snd_hda_create_spdif_out_ctls(codec,
1460                                                     spec->multiout.dig_out_nid,
1461                                                     spec->multiout.dig_out_nid);
1462                 if (err < 0)
1463                         return err;
1464                 err = snd_hda_create_spdif_share_sw(codec,
1465                                                     &spec->multiout);
1466                 if (err < 0)
1467                         return err;
1468                 spec->multiout.share_spdif = 1;
1469         }
1470         if (spec->dig_in_nid) {
1471                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1472                 if (err < 0)
1473                         return err;
1474         }
1475
1476         /* if we have no master control, let's create it */
1477         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1478                 unsigned int vmaster_tlv[4];
1479                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1480                                         HDA_OUTPUT, vmaster_tlv);
1481                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1482                                           vmaster_tlv, via_slave_vols);
1483                 if (err < 0)
1484                         return err;
1485         }
1486         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1487                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1488                                           NULL, via_slave_sws);
1489                 if (err < 0)
1490                         return err;
1491         }
1492
1493         /* assign Capture Source enums to NID */
1494         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1495         for (i = 0; kctl && i < kctl->count; i++) {
1496                 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1497                 if (err < 0)
1498                         return err;
1499         }
1500
1501         /* init power states */
1502         set_widgets_power_state(codec);
1503         analog_low_current_mode(codec);
1504
1505         via_free_kctls(codec); /* no longer needed */
1506         return 0;
1507 }
1508
1509 static int via_build_pcms(struct hda_codec *codec)
1510 {
1511         struct via_spec *spec = codec->spec;
1512         struct hda_pcm *info = spec->pcm_rec;
1513
1514         codec->num_pcms = 0;
1515         codec->pcm_info = info;
1516
1517         if (spec->multiout.num_dacs || spec->num_adc_nids) {
1518                 snprintf(spec->stream_name_analog,
1519                          sizeof(spec->stream_name_analog),
1520                          "%s Analog", codec->chip_name);
1521                 info->name = spec->stream_name_analog;
1522
1523                 if (spec->multiout.num_dacs) {
1524                         if (!spec->stream_analog_playback)
1525                                 spec->stream_analog_playback =
1526                                         &via_pcm_analog_playback;
1527                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1528                                 *spec->stream_analog_playback;
1529                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1530                                 spec->multiout.dac_nids[0];
1531                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1532                                 spec->multiout.max_channels;
1533                 }
1534
1535                 if (!spec->stream_analog_capture) {
1536                         if (spec->dyn_adc_switch)
1537                                 spec->stream_analog_capture =
1538                                         &via_pcm_dyn_adc_analog_capture;
1539                         else
1540                                 spec->stream_analog_capture =
1541                                         &via_pcm_analog_capture;
1542                 }
1543                 if (spec->num_adc_nids) {
1544                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1545                                 *spec->stream_analog_capture;
1546                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1547                                 spec->adc_nids[0];
1548                         if (!spec->dyn_adc_switch)
1549                                 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
1550                                         spec->num_adc_nids;
1551                 }
1552                 codec->num_pcms++;
1553                 info++;
1554         }
1555
1556         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1557                 snprintf(spec->stream_name_digital,
1558                          sizeof(spec->stream_name_digital),
1559                          "%s Digital", codec->chip_name);
1560                 info->name = spec->stream_name_digital;
1561                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1562                 if (spec->multiout.dig_out_nid) {
1563                         if (!spec->stream_digital_playback)
1564                                 spec->stream_digital_playback =
1565                                         &via_pcm_digital_playback;
1566                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1567                                 *spec->stream_digital_playback;
1568                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1569                                 spec->multiout.dig_out_nid;
1570                 }
1571                 if (spec->dig_in_nid) {
1572                         if (!spec->stream_digital_capture)
1573                                 spec->stream_digital_capture =
1574                                         &via_pcm_digital_capture;
1575                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1576                                 *spec->stream_digital_capture;
1577                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1578                                 spec->dig_in_nid;
1579                 }
1580                 codec->num_pcms++;
1581                 info++;
1582         }
1583
1584         if (spec->hp_dac_nid) {
1585                 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
1586                          "%s HP", codec->chip_name);
1587                 info->name = spec->stream_name_hp;
1588                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
1589                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1590                         spec->hp_dac_nid;
1591                 codec->num_pcms++;
1592                 info++;
1593         }
1594         return 0;
1595 }
1596
1597 static void via_free(struct hda_codec *codec)
1598 {
1599         struct via_spec *spec = codec->spec;
1600
1601         if (!spec)
1602                 return;
1603
1604         via_free_kctls(codec);
1605         vt1708_stop_hp_work(spec);
1606         kfree(spec->bind_cap_vol);
1607         kfree(spec->bind_cap_sw);
1608         kfree(spec);
1609 }
1610
1611 /* mute/unmute outputs */
1612 static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
1613                                 hda_nid_t *pins, bool mute)
1614 {
1615         int i;
1616         for (i = 0; i < num_pins; i++) {
1617                 unsigned int parm = snd_hda_codec_read(codec, pins[i], 0,
1618                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1619                 if (parm & AC_PINCTL_IN_EN)
1620                         continue;
1621                 if (mute)
1622                         parm &= ~AC_PINCTL_OUT_EN;
1623                 else
1624                         parm |= AC_PINCTL_OUT_EN;
1625                 snd_hda_codec_write(codec, pins[i], 0,
1626                                     AC_VERB_SET_PIN_WIDGET_CONTROL, parm);
1627         }
1628 }
1629
1630 /* mute internal speaker if line-out is plugged */
1631 static void via_line_automute(struct hda_codec *codec, int present)
1632 {
1633         struct via_spec *spec = codec->spec;
1634
1635         if (!spec->autocfg.speaker_outs)
1636                 return;
1637         if (!present)
1638                 present = snd_hda_jack_detect(codec,
1639                                               spec->autocfg.line_out_pins[0]);
1640         toggle_output_mutes(codec, spec->autocfg.speaker_outs,
1641                             spec->autocfg.speaker_pins,
1642                             present);
1643 }
1644
1645 /* mute internal speaker if HP is plugged */
1646 static void via_hp_automute(struct hda_codec *codec)
1647 {
1648         int present = 0;
1649         int nums;
1650         struct via_spec *spec = codec->spec;
1651
1652         if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0] &&
1653             (spec->codec_type != VT1708 || spec->vt1708_jack_detect))
1654                 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1655
1656         if (spec->smart51_enabled)
1657                 nums = spec->autocfg.line_outs + spec->smart51_nums;
1658         else
1659                 nums = spec->autocfg.line_outs;
1660         toggle_output_mutes(codec, nums, spec->autocfg.line_out_pins, present);
1661
1662         via_line_automute(codec, present);
1663 }
1664
1665 static void via_gpio_control(struct hda_codec *codec)
1666 {
1667         unsigned int gpio_data;
1668         unsigned int vol_counter;
1669         unsigned int vol;
1670         unsigned int master_vol;
1671
1672         struct via_spec *spec = codec->spec;
1673
1674         gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
1675                                        AC_VERB_GET_GPIO_DATA, 0) & 0x03;
1676
1677         vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
1678                                           0xF84, 0) & 0x3F0000) >> 16;
1679
1680         vol = vol_counter & 0x1F;
1681         master_vol = snd_hda_codec_read(codec, 0x1A, 0,
1682                                         AC_VERB_GET_AMP_GAIN_MUTE,
1683                                         AC_AMP_GET_INPUT);
1684
1685         if (gpio_data == 0x02) {
1686                 /* unmute line out */
1687                 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1688                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1689                                     PIN_OUT);
1690                 if (vol_counter & 0x20) {
1691                         /* decrease volume */
1692                         if (vol > master_vol)
1693                                 vol = master_vol;
1694                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1695                                                  0, HDA_AMP_VOLMASK,
1696                                                  master_vol-vol);
1697                 } else {
1698                         /* increase volume */
1699                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1700                                          HDA_AMP_VOLMASK,
1701                                          ((master_vol+vol) > 0x2A) ? 0x2A :
1702                                           (master_vol+vol));
1703                 }
1704         } else if (!(gpio_data & 0x02)) {
1705                 /* mute line out */
1706                 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1707                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1708                                     0);
1709         }
1710 }
1711
1712 /* unsolicited event for jack sensing */
1713 static void via_unsol_event(struct hda_codec *codec,
1714                                   unsigned int res)
1715 {
1716         res >>= 26;
1717
1718         if (res & VIA_JACK_EVENT)
1719                 set_widgets_power_state(codec);
1720
1721         res &= ~VIA_JACK_EVENT;
1722
1723         if (res == VIA_HP_EVENT || res == VIA_LINE_EVENT)
1724                 via_hp_automute(codec);
1725         else if (res == VIA_GPIO_EVENT)
1726                 via_gpio_control(codec);
1727 }
1728
1729 #ifdef CONFIG_PM
1730 static int via_suspend(struct hda_codec *codec, pm_message_t state)
1731 {
1732         struct via_spec *spec = codec->spec;
1733         vt1708_stop_hp_work(spec);
1734         return 0;
1735 }
1736 #endif
1737
1738 #ifdef CONFIG_SND_HDA_POWER_SAVE
1739 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1740 {
1741         struct via_spec *spec = codec->spec;
1742         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1743 }
1744 #endif
1745
1746 /*
1747  */
1748
1749 static int via_init(struct hda_codec *codec);
1750
1751 static const struct hda_codec_ops via_patch_ops = {
1752         .build_controls = via_build_controls,
1753         .build_pcms = via_build_pcms,
1754         .init = via_init,
1755         .free = via_free,
1756         .unsol_event = via_unsol_event,
1757 #ifdef CONFIG_PM
1758         .suspend = via_suspend,
1759 #endif
1760 #ifdef CONFIG_SND_HDA_POWER_SAVE
1761         .check_power_status = via_check_power_status,
1762 #endif
1763 };
1764
1765 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
1766 {
1767         struct via_spec *spec = codec->spec;
1768         int i;
1769
1770         for (i = 0; i < spec->multiout.num_dacs; i++) {
1771                 if (spec->multiout.dac_nids[i] == dac)
1772                         return false;
1773         }
1774         if (spec->hp_dac_nid == dac)
1775                 return false;
1776         return true;
1777 }
1778
1779 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1780                                 hda_nid_t target_dac, int with_aa_mix,
1781                                 struct nid_path *path, int depth)
1782 {
1783         struct via_spec *spec = codec->spec;
1784         hda_nid_t conn[8];
1785         int i, nums;
1786
1787         if (nid == spec->aa_mix_nid) {
1788                 if (!with_aa_mix)
1789                         return false;
1790                 with_aa_mix = 2; /* mark aa-mix is included */
1791         }
1792
1793         nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
1794         for (i = 0; i < nums; i++) {
1795                 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
1796                         continue;
1797                 if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) {
1798                         /* aa-mix is requested but not included? */
1799                         if (!(spec->aa_mix_nid && with_aa_mix == 1))
1800                                 goto found;
1801                 }
1802         }
1803         if (depth >= MAX_NID_PATH_DEPTH)
1804                 return false;
1805         for (i = 0; i < nums; i++) {
1806                 unsigned int type;
1807                 type = get_wcaps_type(get_wcaps(codec, conn[i]));
1808                 if (type == AC_WID_AUD_OUT)
1809                         continue;
1810                 if (__parse_output_path(codec, conn[i], target_dac,
1811                                         with_aa_mix, path, depth + 1))
1812                         goto found;
1813         }
1814         return false;
1815
1816  found:
1817         path->path[path->depth] = conn[i];
1818         path->idx[path->depth] = i;
1819         if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
1820                 path->multi[path->depth] = 1;
1821         path->depth++;
1822         return true;
1823 }
1824
1825 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1826                               hda_nid_t target_dac, int with_aa_mix,
1827                               struct nid_path *path)
1828 {
1829         if (__parse_output_path(codec, nid, target_dac, with_aa_mix, path, 1)) {
1830                 path->path[path->depth] = nid;
1831                 path->depth++;
1832                 snd_printdd("output-path: depth=%d, %02x/%02x/%02x/%02x/%02x\n",
1833                             path->depth, path->path[0], path->path[1],
1834                             path->path[2], path->path[3], path->path[4]);
1835                 return true;
1836         }
1837         return false;
1838 }
1839
1840 static int via_auto_fill_dac_nids(struct hda_codec *codec)
1841 {
1842         struct via_spec *spec = codec->spec;
1843         const struct auto_pin_cfg *cfg = &spec->autocfg;
1844         int i, dac_num;
1845         hda_nid_t nid;
1846
1847         spec->multiout.dac_nids = spec->private_dac_nids;
1848         dac_num = 0;
1849         for (i = 0; i < cfg->line_outs; i++) {
1850                 hda_nid_t dac = 0;
1851                 nid = cfg->line_out_pins[i];
1852                 if (!nid)
1853                         continue;
1854                 if (parse_output_path(codec, nid, 0, 0, &spec->out_path[i]))
1855                         dac = spec->out_path[i].path[0];
1856                 if (!i && parse_output_path(codec, nid, dac, 1,
1857                                             &spec->out_mix_path))
1858                         dac = spec->out_mix_path.path[0];
1859                 if (dac) {
1860                         spec->private_dac_nids[i] = dac;
1861                         dac_num++;
1862                 }
1863         }
1864         if (!spec->out_path[0].depth && spec->out_mix_path.depth) {
1865                 spec->out_path[0] = spec->out_mix_path;
1866                 spec->out_mix_path.depth = 0;
1867         }
1868         spec->multiout.num_dacs = dac_num;
1869         return 0;
1870 }
1871
1872 static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1873                           int chs, bool check_dac, struct nid_path *path)
1874 {
1875         struct via_spec *spec = codec->spec;
1876         char name[32];
1877         hda_nid_t dac, pin, sel, nid;
1878         int err;
1879
1880         dac = check_dac ? path->path[0] : 0;
1881         pin = path->path[path->depth - 1];
1882         sel = path->depth > 1 ? path->path[1] : 0;
1883
1884         if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1885                 nid = dac;
1886         else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1887                 nid = pin;
1888         else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1889                 nid = sel;
1890         else
1891                 nid = 0;
1892         if (nid) {
1893                 sprintf(name, "%s Playback Volume", pfx);
1894                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1895                               HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1896                 if (err < 0)
1897                         return err;
1898                 path->vol_ctl = nid;
1899         }
1900
1901         if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1902                 nid = dac;
1903         else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1904                 nid = pin;
1905         else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE))
1906                 nid = sel;
1907         else
1908                 nid = 0;
1909         if (nid) {
1910                 sprintf(name, "%s Playback Switch", pfx);
1911                 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1912                               HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1913                 if (err < 0)
1914                         return err;
1915                 path->mute_ctl = nid;
1916         }
1917         return 0;
1918 }
1919
1920 static void mangle_smart51(struct hda_codec *codec)
1921 {
1922         struct via_spec *spec = codec->spec;
1923         struct auto_pin_cfg *cfg = &spec->autocfg;
1924         struct auto_pin_cfg_item *ins = cfg->inputs;
1925         int i, j, nums, attr;
1926         int pins[AUTO_CFG_MAX_INS];
1927
1928         for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
1929                 nums = 0;
1930                 for (i = 0; i < cfg->num_inputs; i++) {
1931                         unsigned int def;
1932                         if (ins[i].type > AUTO_PIN_LINE_IN)
1933                                 continue;
1934                         def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
1935                         if (snd_hda_get_input_pin_attr(def) != attr)
1936                                 continue;
1937                         for (j = 0; j < nums; j++)
1938                                 if (ins[pins[j]].type < ins[i].type) {
1939                                         memmove(pins + j + 1, pins + j,
1940                                                 (nums - j) * sizeof(int));
1941                                         break;
1942                                 }
1943                         pins[j] = i;
1944                         nums++;
1945                 }
1946                 if (cfg->line_outs + nums < 3)
1947                         continue;
1948                 for (i = 0; i < nums; i++) {
1949                         hda_nid_t pin = ins[pins[i]].pin;
1950                         spec->smart51_pins[spec->smart51_nums++] = pin;
1951                         cfg->line_out_pins[cfg->line_outs++] = pin;
1952                         if (cfg->line_outs == 3)
1953                                 break;
1954                 }
1955                 return;
1956         }
1957 }
1958
1959 static void copy_path_mixer_ctls(struct nid_path *dst, struct nid_path *src)
1960 {
1961         dst->vol_ctl = src->vol_ctl;
1962         dst->mute_ctl = src->mute_ctl;
1963 }
1964
1965 /* add playback controls from the parsed DAC table */
1966 static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1967 {
1968         struct via_spec *spec = codec->spec;
1969         struct auto_pin_cfg *cfg = &spec->autocfg;
1970         struct nid_path *path;
1971         static const char * const chname[4] = {
1972                 "Front", "Surround", "C/LFE", "Side"
1973         };
1974         int i, idx, err;
1975         int old_line_outs;
1976
1977         /* check smart51 */
1978         old_line_outs = cfg->line_outs;
1979         if (cfg->line_outs == 1)
1980                 mangle_smart51(codec);
1981
1982         err = via_auto_fill_dac_nids(codec);
1983         if (err < 0)
1984                 return err;
1985
1986         if (spec->multiout.num_dacs < 3) {
1987                 spec->smart51_nums = 0;
1988                 cfg->line_outs = old_line_outs;
1989         }
1990         for (i = 0; i < cfg->line_outs; i++) {
1991                 hda_nid_t pin, dac;
1992                 pin = cfg->line_out_pins[i];
1993                 dac = spec->multiout.dac_nids[i];
1994                 if (!pin || !dac)
1995                         continue;
1996                 path = spec->out_path + i;
1997                 if (i == HDA_CLFE) {
1998                         err = create_ch_ctls(codec, "Center", 1, true, path);
1999                         if (err < 0)
2000                                 return err;
2001                         err = create_ch_ctls(codec, "LFE", 2, true, path);
2002                         if (err < 0)
2003                                 return err;
2004                 } else {
2005                         const char *pfx = chname[i];
2006                         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
2007                             cfg->line_outs == 1)
2008                                 pfx = "Speaker";
2009                         err = create_ch_ctls(codec, pfx, 3, true, path);
2010                         if (err < 0)
2011                                 return err;
2012                 }
2013                 if (path != spec->out_path + i)
2014                         copy_path_mixer_ctls(&spec->out_path[i], path);
2015                 if (path == spec->out_path && spec->out_mix_path.depth)
2016                         copy_path_mixer_ctls(&spec->out_mix_path, path);
2017         }
2018
2019         idx = get_connection_index(codec, spec->aa_mix_nid,
2020                                    spec->multiout.dac_nids[0]);
2021         if (idx >= 0) {
2022                 /* add control to mixer */
2023                 const char *name;
2024                 name = spec->out_mix_path.depth ?
2025                         "PCM Loopback Playback Volume" : "PCM Playback Volume";
2026                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2027                                       HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2028                                                           idx, HDA_INPUT));
2029                 if (err < 0)
2030                         return err;
2031                 name = spec->out_mix_path.depth ?
2032                         "PCM Loopback Playback Switch" : "PCM Playback Switch";
2033                 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2034                                       HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2035                                                           idx, HDA_INPUT));
2036                 if (err < 0)
2037                         return err;
2038         }
2039
2040         cfg->line_outs = old_line_outs;
2041
2042         return 0;
2043 }
2044
2045 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
2046 {
2047         struct via_spec *spec = codec->spec;
2048         struct nid_path *path;
2049         bool check_dac;
2050         int i, err;
2051
2052         if (!pin)
2053                 return 0;
2054
2055         if (!parse_output_path(codec, pin, 0, 0, &spec->hp_indep_path)) {
2056                 for (i = HDA_SIDE; i >= HDA_CLFE; i--) {
2057                         if (i < spec->multiout.num_dacs &&
2058                             parse_output_path(codec, pin,
2059                                               spec->multiout.dac_nids[i], 0,
2060                                               &spec->hp_indep_path)) {
2061                                 spec->hp_indep_shared = i;
2062                                 break;
2063                         }
2064                 }
2065         }
2066         if (spec->hp_indep_path.depth) {
2067                 spec->hp_dac_nid = spec->hp_indep_path.path[0];
2068                 if (!spec->hp_indep_shared)
2069                         spec->hp_path = spec->hp_indep_path;
2070         }
2071         /* optionally check front-path w/o AA-mix */
2072         if (!spec->hp_path.depth)
2073                 parse_output_path(codec, pin,
2074                                   spec->multiout.dac_nids[HDA_FRONT], 0,
2075                                   &spec->hp_path);
2076
2077         if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2078                                1, &spec->hp_mix_path) && !spec->hp_path.depth)
2079                 return 0;
2080
2081         if (spec->hp_path.depth) {
2082                 path = &spec->hp_path;
2083                 check_dac = true;
2084         } else {
2085                 path = &spec->hp_mix_path;
2086                 check_dac = false;
2087         }
2088         err = create_ch_ctls(codec, "Headphone", 3, check_dac, path);
2089         if (err < 0)
2090                 return err;
2091         if (check_dac)
2092                 copy_path_mixer_ctls(&spec->hp_mix_path, path);
2093         else
2094                 copy_path_mixer_ctls(&spec->hp_path, path);
2095         if (spec->hp_indep_path.depth)
2096                 copy_path_mixer_ctls(&spec->hp_indep_path, path);
2097         return 0;
2098 }
2099
2100 static int via_auto_create_speaker_ctls(struct hda_codec *codec)
2101 {
2102         struct via_spec *spec = codec->spec;
2103         struct nid_path *path;
2104         bool check_dac;
2105         hda_nid_t pin, dac = 0;
2106         int err;
2107
2108         pin = spec->autocfg.speaker_pins[0];
2109         if (!spec->autocfg.speaker_outs || !pin)
2110                 return 0;
2111
2112         if (parse_output_path(codec, pin, 0, 0, &spec->speaker_path))
2113                 dac = spec->speaker_path.path[0];
2114         if (!dac)
2115                 parse_output_path(codec, pin,
2116                                   spec->multiout.dac_nids[HDA_FRONT], 0,
2117                                   &spec->speaker_path);
2118         if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2119                                1, &spec->speaker_mix_path) && !dac)
2120                 return 0;
2121
2122         /* no AA-path for front? */
2123         if (!spec->out_mix_path.depth && spec->speaker_mix_path.depth)
2124                 dac = 0;
2125
2126         spec->speaker_dac_nid = dac;
2127         spec->multiout.extra_out_nid[0] = dac;
2128         if (dac) {
2129                 path = &spec->speaker_path;
2130                 check_dac = true;
2131         } else {
2132                 path = &spec->speaker_mix_path;
2133                 check_dac = false;
2134         }
2135         err = create_ch_ctls(codec, "Speaker", 3, check_dac, path);
2136         if (err < 0)
2137                 return err;
2138         if (check_dac)
2139                 copy_path_mixer_ctls(&spec->speaker_mix_path, path);
2140         else
2141                 copy_path_mixer_ctls(&spec->speaker_path, path);
2142         return 0;
2143 }
2144
2145 #define via_aamix_ctl_info      via_pin_power_ctl_info
2146
2147 static int via_aamix_ctl_get(struct snd_kcontrol *kcontrol,
2148                              struct snd_ctl_elem_value *ucontrol)
2149 {
2150         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2151         struct via_spec *spec = codec->spec;
2152         ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2153         return 0;
2154 }
2155
2156 static void update_aamix_paths(struct hda_codec *codec, int do_mix,
2157                                struct nid_path *nomix, struct nid_path *mix)
2158 {
2159         if (do_mix) {
2160                 activate_output_path(codec, nomix, false, false);
2161                 activate_output_path(codec, mix, true, false);
2162         } else {
2163                 activate_output_path(codec, mix, false, false);
2164                 activate_output_path(codec, nomix, true, false);
2165         }
2166 }
2167
2168 static int via_aamix_ctl_put(struct snd_kcontrol *kcontrol,
2169                              struct snd_ctl_elem_value *ucontrol)
2170 {
2171         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2172         struct via_spec *spec = codec->spec;
2173         unsigned int val = ucontrol->value.enumerated.item[0];
2174
2175         if (val == spec->aamix_mode)
2176                 return 0;
2177         spec->aamix_mode = val;
2178         /* update front path */
2179         update_aamix_paths(codec, val, &spec->out_path[0], &spec->out_mix_path);
2180         /* update HP path */
2181         if (!spec->hp_independent_mode) {
2182                 update_aamix_paths(codec, val, &spec->hp_path,
2183                                    &spec->hp_mix_path);
2184         }
2185         /* update speaker path */
2186         update_aamix_paths(codec, val, &spec->speaker_path,
2187                            &spec->speaker_mix_path);
2188         return 1;
2189 }
2190
2191 static const struct snd_kcontrol_new via_aamix_ctl_enum = {
2192         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2193         .name = "Loopback Mixing",
2194         .info = via_aamix_ctl_info,
2195         .get = via_aamix_ctl_get,
2196         .put = via_aamix_ctl_put,
2197 };
2198
2199 static int via_auto_create_loopback_switch(struct hda_codec *codec)
2200 {
2201         struct via_spec *spec = codec->spec;
2202
2203         if (!spec->aa_mix_nid || !spec->out_mix_path.depth)
2204                 return 0; /* no loopback switching available */
2205         if (!via_clone_control(spec, &via_aamix_ctl_enum))
2206                 return -ENOMEM;
2207         return 0;
2208 }
2209
2210 /* look for ADCs */
2211 static int via_fill_adcs(struct hda_codec *codec)
2212 {
2213         struct via_spec *spec = codec->spec;
2214         hda_nid_t nid = codec->start_nid;
2215         int i;
2216
2217         for (i = 0; i < codec->num_nodes; i++, nid++) {
2218                 unsigned int wcaps = get_wcaps(codec, nid);
2219                 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2220                         continue;
2221                 if (wcaps & AC_WCAP_DIGITAL)
2222                         continue;
2223                 if (!(wcaps & AC_WCAP_CONN_LIST))
2224                         continue;
2225                 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
2226                         return -ENOMEM;
2227                 spec->adc_nids[spec->num_adc_nids++] = nid;
2228         }
2229         return 0;
2230 }
2231
2232 /* input-src control */
2233 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
2234                              struct snd_ctl_elem_info *uinfo)
2235 {
2236         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2237         struct via_spec *spec = codec->spec;
2238
2239         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2240         uinfo->count = 1;
2241         uinfo->value.enumerated.items = spec->num_inputs;
2242         if (uinfo->value.enumerated.item >= spec->num_inputs)
2243                 uinfo->value.enumerated.item = spec->num_inputs - 1;
2244         strcpy(uinfo->value.enumerated.name,
2245                spec->inputs[uinfo->value.enumerated.item].label);
2246         return 0;
2247 }
2248
2249 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
2250                             struct snd_ctl_elem_value *ucontrol)
2251 {
2252         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2253         struct via_spec *spec = codec->spec;
2254         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2255
2256         ucontrol->value.enumerated.item[0] = spec->cur_mux[idx];
2257         return 0;
2258 }
2259
2260 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
2261                             struct snd_ctl_elem_value *ucontrol)
2262 {
2263         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2264         struct via_spec *spec = codec->spec;
2265         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2266         hda_nid_t mux;
2267         int cur;
2268
2269         cur = ucontrol->value.enumerated.item[0];
2270         if (cur < 0 || cur >= spec->num_inputs)
2271                 return -EINVAL;
2272         if (spec->cur_mux[idx] == cur)
2273                 return 0;
2274         spec->cur_mux[idx] = cur;
2275         if (spec->dyn_adc_switch) {
2276                 int adc_idx = spec->inputs[cur].adc_idx;
2277                 mux = spec->mux_nids[adc_idx];
2278                 via_dyn_adc_pcm_resetup(codec, cur);
2279         } else {
2280                 mux = spec->mux_nids[idx];
2281                 if (snd_BUG_ON(!mux))
2282                         return -EINVAL;
2283         }
2284
2285         if (mux) {
2286                 /* switch to D0 beofre change index */
2287                 if (snd_hda_codec_read(codec, mux, 0,
2288                                AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
2289                         snd_hda_codec_write(codec, mux, 0,
2290                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2291                 snd_hda_codec_write(codec, mux, 0,
2292                                     AC_VERB_SET_CONNECT_SEL,
2293                                     spec->inputs[cur].mux_idx);
2294         }
2295
2296         /* update jack power state */
2297         set_widgets_power_state(codec);
2298         return 0;
2299 }
2300
2301 static const struct snd_kcontrol_new via_input_src_ctl = {
2302         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2303         /* The multiple "Capture Source" controls confuse alsamixer
2304          * So call somewhat different..
2305          */
2306         /* .name = "Capture Source", */
2307         .name = "Input Source",
2308         .info = via_mux_enum_info,
2309         .get = via_mux_enum_get,
2310         .put = via_mux_enum_put,
2311 };
2312
2313 static int create_input_src_ctls(struct hda_codec *codec, int count)
2314 {
2315         struct via_spec *spec = codec->spec;
2316         struct snd_kcontrol_new *knew;
2317
2318         if (spec->num_inputs <= 1 || !count)
2319                 return 0; /* no need for single src */
2320
2321         knew = via_clone_control(spec, &via_input_src_ctl);
2322         if (!knew)
2323                 return -ENOMEM;
2324         knew->count = count;
2325         return 0;
2326 }
2327
2328 /* add the powersave loopback-list entry */
2329 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
2330 {
2331         struct hda_amp_list *list;
2332
2333         if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
2334                 return;
2335         list = spec->loopback_list + spec->num_loopbacks;
2336         list->nid = mix;
2337         list->dir = HDA_INPUT;
2338         list->idx = idx;
2339         spec->num_loopbacks++;
2340         spec->loopback.amplist = spec->loopback_list;
2341 }
2342
2343 static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src,
2344                              hda_nid_t dst)
2345 {
2346         return snd_hda_get_conn_index(codec, src, dst, 1) >= 0;
2347 }
2348
2349 /* add the input-route to the given pin */
2350 static bool add_input_route(struct hda_codec *codec, hda_nid_t pin)
2351 {
2352         struct via_spec *spec = codec->spec;
2353         int c, idx;
2354
2355         spec->inputs[spec->num_inputs].adc_idx = -1;
2356         spec->inputs[spec->num_inputs].pin = pin;
2357         for (c = 0; c < spec->num_adc_nids; c++) {
2358                 if (spec->mux_nids[c]) {
2359                         idx = get_connection_index(codec, spec->mux_nids[c],
2360                                                    pin);
2361                         if (idx < 0)
2362                                 continue;
2363                         spec->inputs[spec->num_inputs].mux_idx = idx;
2364                 } else {
2365                         if (!is_reachable_nid(codec, spec->adc_nids[c], pin))
2366                                 continue;
2367                 }
2368                 spec->inputs[spec->num_inputs].adc_idx = c;
2369                 /* Can primary ADC satisfy all inputs? */
2370                 if (!spec->dyn_adc_switch &&
2371                     spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) {
2372                         snd_printd(KERN_INFO
2373                                    "via: dynamic ADC switching enabled\n");
2374                         spec->dyn_adc_switch = 1;
2375                 }
2376                 return true;
2377         }
2378         return false;
2379 }
2380
2381 static int get_mux_nids(struct hda_codec *codec);
2382
2383 /* parse input-routes; fill ADCs, MUXs and input-src entries */
2384 static int parse_analog_inputs(struct hda_codec *codec)
2385 {
2386         struct via_spec *spec = codec->spec;
2387         const struct auto_pin_cfg *cfg = &spec->autocfg;
2388         int i, err;
2389
2390         err = via_fill_adcs(codec);
2391         if (err < 0)
2392                 return err;
2393         err = get_mux_nids(codec);
2394         if (err < 0)
2395                 return err;
2396
2397         /* fill all input-routes */
2398         for (i = 0; i < cfg->num_inputs; i++) {
2399                 if (add_input_route(codec, cfg->inputs[i].pin))
2400                         spec->inputs[spec->num_inputs++].label =
2401                                 hda_get_autocfg_input_label(codec, cfg, i);
2402         }
2403
2404         /* check for internal loopback recording */
2405         if (spec->aa_mix_nid &&
2406             add_input_route(codec, spec->aa_mix_nid))
2407                 spec->inputs[spec->num_inputs++].label = "Stereo Mixer";
2408
2409         return 0;
2410 }
2411
2412 /* create analog-loopback volume/switch controls */
2413 static int create_loopback_ctls(struct hda_codec *codec)
2414 {
2415         struct via_spec *spec = codec->spec;
2416         const struct auto_pin_cfg *cfg = &spec->autocfg;
2417         const char *prev_label = NULL;
2418         int type_idx = 0;
2419         int i, j, err, idx;
2420
2421         if (!spec->aa_mix_nid)
2422                 return 0;
2423
2424         for (i = 0; i < cfg->num_inputs; i++) {
2425                 hda_nid_t pin = cfg->inputs[i].pin;
2426                 const char *label = hda_get_autocfg_input_label(codec, cfg, i);
2427
2428                 if (prev_label && !strcmp(label, prev_label))
2429                         type_idx++;
2430                 else
2431                         type_idx = 0;
2432                 prev_label = label;
2433                 idx = get_connection_index(codec, spec->aa_mix_nid, pin);
2434                 if (idx >= 0) {
2435                         err = via_new_analog_input(spec, label, type_idx,
2436                                                    idx, spec->aa_mix_nid);
2437                         if (err < 0)
2438                                 return err;
2439                         add_loopback_list(spec, spec->aa_mix_nid, idx);
2440                 }
2441
2442                 /* remember the label for smart51 control */
2443                 for (j = 0; j < spec->smart51_nums; j++) {
2444                         if (spec->smart51_pins[j] == pin) {
2445                                 spec->smart51_idxs[j] = idx;
2446                                 spec->smart51_labels[j] = label;
2447                                 break;
2448                         }
2449                 }
2450         }
2451         return 0;
2452 }
2453
2454 /* create mic-boost controls (if present) */
2455 static int create_mic_boost_ctls(struct hda_codec *codec)
2456 {
2457         struct via_spec *spec = codec->spec;
2458         const struct auto_pin_cfg *cfg = &spec->autocfg;
2459         int i, err;
2460
2461         for (i = 0; i < cfg->num_inputs; i++) {
2462                 hda_nid_t pin = cfg->inputs[i].pin;
2463                 unsigned int caps;
2464                 const char *label;
2465                 char name[32];
2466
2467                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2468                         continue;
2469                 caps = query_amp_caps(codec, pin, HDA_INPUT);
2470                 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
2471                         continue;
2472                 label = hda_get_autocfg_input_label(codec, cfg, i);
2473                 snprintf(name, sizeof(name), "%s Boost Volume", label);
2474                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2475                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
2476                 if (err < 0)
2477                         return err;
2478         }
2479         return 0;
2480 }
2481
2482 /* create capture and input-src controls for multiple streams */
2483 static int create_multi_adc_ctls(struct hda_codec *codec)
2484 {
2485         struct via_spec *spec = codec->spec;
2486         int i, err;
2487
2488         /* create capture mixer elements */
2489         for (i = 0; i < spec->num_adc_nids; i++) {
2490                 hda_nid_t adc = spec->adc_nids[i];
2491                 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
2492                                         "Capture Volume", i,
2493                                         HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2494                                                             HDA_INPUT));
2495                 if (err < 0)
2496                         return err;
2497                 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2498                                         "Capture Switch", i,
2499                                         HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2500                                                             HDA_INPUT));
2501                 if (err < 0)
2502                         return err;
2503         }
2504
2505         /* input-source control */
2506         for (i = 0; i < spec->num_adc_nids; i++)
2507                 if (!spec->mux_nids[i])
2508                         break;
2509         err = create_input_src_ctls(codec, i);
2510         if (err < 0)
2511                 return err;
2512         return 0;
2513 }
2514
2515 /* bind capture volume/switch */
2516 static struct snd_kcontrol_new via_bind_cap_vol_ctl =
2517         HDA_BIND_VOL("Capture Volume", 0);
2518 static struct snd_kcontrol_new via_bind_cap_sw_ctl =
2519         HDA_BIND_SW("Capture Switch", 0);
2520
2521 static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret,
2522                          struct hda_ctl_ops *ops)
2523 {
2524         struct hda_bind_ctls *ctl;
2525         int i;
2526
2527         ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL);
2528         if (!ctl)
2529                 return -ENOMEM;
2530         ctl->ops = ops;
2531         for (i = 0; i < spec->num_adc_nids; i++)
2532                 ctl->values[i] =
2533                         HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT);
2534         *ctl_ret = ctl;
2535         return 0;
2536 }
2537
2538 /* create capture and input-src controls for dynamic ADC-switch case */
2539 static int create_dyn_adc_ctls(struct hda_codec *codec)
2540 {
2541         struct via_spec *spec = codec->spec;
2542         struct snd_kcontrol_new *knew;
2543         int err;
2544
2545         /* set up the bind capture ctls */
2546         err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol);
2547         if (err < 0)
2548                 return err;
2549         err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw);
2550         if (err < 0)
2551                 return err;
2552
2553         /* create capture mixer elements */
2554         knew = via_clone_control(spec, &via_bind_cap_vol_ctl);
2555         if (!knew)
2556                 return -ENOMEM;
2557         knew->private_value = (long)spec->bind_cap_vol;
2558
2559         knew = via_clone_control(spec, &via_bind_cap_sw_ctl);
2560         if (!knew)
2561                 return -ENOMEM;
2562         knew->private_value = (long)spec->bind_cap_sw;
2563
2564         /* input-source control */
2565         err = create_input_src_ctls(codec, 1);
2566         if (err < 0)
2567                 return err;
2568         return 0;
2569 }
2570
2571 /* parse and create capture-related stuff */
2572 static int via_auto_create_analog_input_ctls(struct hda_codec *codec)
2573 {
2574         struct via_spec *spec = codec->spec;
2575         int err;
2576
2577         err = parse_analog_inputs(codec);
2578         if (err < 0)
2579                 return err;
2580         if (spec->dyn_adc_switch)
2581                 err = create_dyn_adc_ctls(codec);
2582         else
2583                 err = create_multi_adc_ctls(codec);
2584         if (err < 0)
2585                 return err;
2586         err = create_loopback_ctls(codec);
2587         if (err < 0)
2588                 return err;
2589         err = create_mic_boost_ctls(codec);
2590         if (err < 0)
2591                 return err;
2592         return 0;
2593 }
2594
2595 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
2596 {
2597         unsigned int def_conf;
2598         unsigned char seqassoc;
2599
2600         def_conf = snd_hda_codec_get_pincfg(codec, nid);
2601         seqassoc = (unsigned char) get_defcfg_association(def_conf);
2602         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2603         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
2604             && (seqassoc == 0xf0 || seqassoc == 0xff)) {
2605                 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2606                 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2607         }
2608
2609         return;
2610 }
2611
2612 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2613                                      struct snd_ctl_elem_value *ucontrol)
2614 {
2615         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2616         struct via_spec *spec = codec->spec;
2617
2618         if (spec->codec_type != VT1708)
2619                 return 0;
2620         ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2621         return 0;
2622 }
2623
2624 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2625                                      struct snd_ctl_elem_value *ucontrol)
2626 {
2627         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2628         struct via_spec *spec = codec->spec;
2629         int val;
2630
2631         if (spec->codec_type != VT1708)
2632                 return 0;
2633         val = !!ucontrol->value.integer.value[0];
2634         if (spec->vt1708_jack_detect == val)
2635                 return 0;
2636         spec->vt1708_jack_detect = val;
2637         if (spec->vt1708_jack_detect &&
2638             snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") != 1) {
2639                 mute_aa_path(codec, 1);
2640                 notify_aa_path_ctls(codec);
2641         }
2642         via_hp_automute(codec);
2643         vt1708_update_hp_work(spec);
2644         return 1;
2645 }
2646
2647 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
2648         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2649         .name = "Jack Detect",
2650         .count = 1,
2651         .info = snd_ctl_boolean_mono_info,
2652         .get = vt1708_jack_detect_get,
2653         .put = vt1708_jack_detect_put,
2654 };
2655
2656 static void fill_dig_outs(struct hda_codec *codec);
2657 static void fill_dig_in(struct hda_codec *codec);
2658
2659 static int via_parse_auto_config(struct hda_codec *codec)
2660 {
2661         struct via_spec *spec = codec->spec;
2662         int err;
2663
2664         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2665         if (err < 0)
2666                 return err;
2667         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2668                 return -EINVAL;
2669
2670         err = via_auto_create_multi_out_ctls(codec);
2671         if (err < 0)
2672                 return err;
2673         err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2674         if (err < 0)
2675                 return err;
2676         err = via_auto_create_speaker_ctls(codec);
2677         if (err < 0)
2678                 return err;
2679         err = via_auto_create_loopback_switch(codec);
2680         if (err < 0)
2681                 return err;
2682         err = via_auto_create_analog_input_ctls(codec);
2683         if (err < 0)
2684                 return err;
2685
2686         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2687
2688         fill_dig_outs(codec);
2689         fill_dig_in(codec);
2690
2691         if (spec->kctls.list)
2692                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2693
2694
2695         if (spec->hp_dac_nid && spec->hp_mix_path.depth) {
2696                 err = via_hp_build(codec);
2697                 if (err < 0)
2698                         return err;
2699         }
2700
2701         err = via_smart51_build(codec);
2702         if (err < 0)
2703                 return err;
2704
2705         /* assign slave outs */
2706         if (spec->slave_dig_outs[0])
2707                 codec->slave_dig_outs = spec->slave_dig_outs;
2708
2709         return 1;
2710 }
2711
2712 static void via_auto_init_dig_outs(struct hda_codec *codec)
2713 {
2714         struct via_spec *spec = codec->spec;
2715         if (spec->multiout.dig_out_nid)
2716                 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
2717         if (spec->slave_dig_outs[0])
2718                 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
2719 }
2720
2721 static void via_auto_init_dig_in(struct hda_codec *codec)
2722 {
2723         struct via_spec *spec = codec->spec;
2724         if (!spec->dig_in_nid)
2725                 return;
2726         snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2727                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2728 }
2729
2730 /* initialize the unsolicited events */
2731 static void via_auto_init_unsol_event(struct hda_codec *codec)
2732 {
2733         struct via_spec *spec = codec->spec;
2734         struct auto_pin_cfg *cfg = &spec->autocfg;
2735         unsigned int ev;
2736         int i;
2737
2738         if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
2739                 snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
2740                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2741                                 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);
2742
2743         if (cfg->speaker_pins[0])
2744                 ev = VIA_LINE_EVENT;
2745         else
2746                 ev = 0;
2747         for (i = 0; i < cfg->line_outs; i++) {
2748                 if (cfg->line_out_pins[i] &&
2749                     is_jack_detectable(codec, cfg->line_out_pins[i]))
2750                         snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
2751                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2752                                 AC_USRSP_EN | ev | VIA_JACK_EVENT);
2753         }
2754
2755         for (i = 0; i < cfg->num_inputs; i++) {
2756                 if (is_jack_detectable(codec, cfg->inputs[i].pin))
2757                         snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
2758                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2759                                 AC_USRSP_EN | VIA_JACK_EVENT);
2760         }
2761 }
2762
2763 static int via_init(struct hda_codec *codec)
2764 {
2765         struct via_spec *spec = codec->spec;
2766         int i;
2767
2768         for (i = 0; i < spec->num_iverbs; i++)
2769                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2770
2771         via_auto_init_multi_out(codec);
2772         via_auto_init_hp_out(codec);
2773         via_auto_init_speaker_out(codec);
2774         via_auto_init_analog_input(codec);
2775         via_auto_init_dig_outs(codec);
2776         via_auto_init_dig_in(codec);
2777
2778         via_auto_init_unsol_event(codec);
2779
2780         via_hp_automute(codec);
2781         vt1708_update_hp_work(spec);
2782
2783         return 0;
2784 }
2785
2786 static void vt1708_update_hp_jack_state(struct work_struct *work)
2787 {
2788         struct via_spec *spec = container_of(work, struct via_spec,
2789                                              vt1708_hp_work.work);
2790         if (spec->codec_type != VT1708)
2791                 return;
2792         /* if jack state toggled */
2793         if (spec->vt1708_hp_present
2794             != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2795                 spec->vt1708_hp_present ^= 1;
2796                 via_hp_automute(spec->codec);
2797         }
2798         if (spec->vt1708_jack_detect)
2799                 schedule_delayed_work(&spec->vt1708_hp_work,
2800                                       msecs_to_jiffies(100));
2801 }
2802
2803 static int get_mux_nids(struct hda_codec *codec)
2804 {
2805         struct via_spec *spec = codec->spec;
2806         hda_nid_t nid, conn[8];
2807         unsigned int type;
2808         int i, n;
2809
2810         for (i = 0; i < spec->num_adc_nids; i++) {
2811                 nid = spec->adc_nids[i];
2812                 while (nid) {
2813                         type = get_wcaps_type(get_wcaps(codec, nid));
2814                         if (type == AC_WID_PIN)
2815                                 break;
2816                         n = snd_hda_get_connections(codec, nid, conn,
2817                                                     ARRAY_SIZE(conn));
2818                         if (n <= 0)
2819                                 break;
2820                         if (n > 1) {
2821                                 spec->mux_nids[i] = nid;
2822                                 break;
2823                         }
2824                         nid = conn[0];
2825                 }
2826         }
2827         return 0;
2828 }
2829
2830 static int patch_vt1708(struct hda_codec *codec)
2831 {
2832         struct via_spec *spec;
2833         int err;
2834
2835         /* create a codec specific record */
2836         spec = via_new_spec(codec);
2837         if (spec == NULL)
2838                 return -ENOMEM;
2839
2840         spec->aa_mix_nid = 0x17;
2841
2842         /* Add HP and CD pin config connect bit re-config action */
2843         vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2844         vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2845
2846         /* automatic parse from the BIOS config */
2847         err = via_parse_auto_config(codec);
2848         if (err < 0) {
2849                 via_free(codec);
2850                 return err;
2851         }
2852
2853         /* add jack detect on/off control */
2854         if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
2855                 return -ENOMEM;
2856
2857         /* disable 32bit format on VT1708 */
2858         if (codec->vendor_id == 0x11061708)
2859                 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2860
2861         spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
2862
2863         codec->patch_ops = via_patch_ops;
2864
2865         INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2866         return 0;
2867 }
2868
2869 static int patch_vt1709(struct hda_codec *codec)
2870 {
2871         struct via_spec *spec;
2872         int err;
2873
2874         /* create a codec specific record */
2875         spec = via_new_spec(codec);
2876         if (spec == NULL)
2877                 return -ENOMEM;
2878
2879         spec->aa_mix_nid = 0x18;
2880
2881         err = via_parse_auto_config(codec);
2882         if (err < 0) {
2883                 via_free(codec);
2884                 return err;
2885         }
2886
2887         codec->patch_ops = via_patch_ops;
2888
2889         return 0;
2890 }
2891
2892 static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
2893 {
2894         struct via_spec *spec = codec->spec;
2895         int imux_is_smixer;
2896         unsigned int parm;
2897         int is_8ch = 0;
2898         if ((spec->codec_type != VT1708B_4CH) &&
2899             (codec->vendor_id != 0x11064397))
2900                 is_8ch = 1;
2901
2902         /* SW0 (17h) = stereo mixer */
2903         imux_is_smixer =
2904         (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
2905          == ((spec->codec_type == VT1708S) ? 5 : 0));
2906         /* inputs */
2907         /* PW 1/2/5 (1ah/1bh/1eh) */
2908         parm = AC_PWRST_D3;
2909         set_pin_power_state(codec, 0x1a, &parm);
2910         set_pin_power_state(codec, 0x1b, &parm);
2911         set_pin_power_state(codec, 0x1e, &parm);
2912         if (imux_is_smixer)
2913                 parm = AC_PWRST_D0;
2914         /* SW0 (17h), AIW 0/1 (13h/14h) */
2915         snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2916         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2917         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2918
2919         /* outputs */
2920         /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2921         parm = AC_PWRST_D3;
2922         set_pin_power_state(codec, 0x19, &parm);
2923         if (spec->smart51_enabled)
2924                 set_pin_power_state(codec, 0x1b, &parm);
2925         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2926         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2927
2928         /* PW6 (22h), SW2 (26h), AOW2 (24h) */
2929         if (is_8ch) {
2930                 parm = AC_PWRST_D3;
2931                 set_pin_power_state(codec, 0x22, &parm);
2932                 if (spec->smart51_enabled)
2933                         set_pin_power_state(codec, 0x1a, &parm);
2934                 snd_hda_codec_write(codec, 0x26, 0,
2935                                     AC_VERB_SET_POWER_STATE, parm);
2936                 snd_hda_codec_write(codec, 0x24, 0,
2937                                     AC_VERB_SET_POWER_STATE, parm);
2938         } else if (codec->vendor_id == 0x11064397) {
2939                 /* PW7(23h), SW2(27h), AOW2(25h) */
2940                 parm = AC_PWRST_D3;
2941                 set_pin_power_state(codec, 0x23, &parm);
2942                 if (spec->smart51_enabled)
2943                         set_pin_power_state(codec, 0x1a, &parm);
2944                 snd_hda_codec_write(codec, 0x27, 0,
2945                                     AC_VERB_SET_POWER_STATE, parm);
2946                 snd_hda_codec_write(codec, 0x25, 0,
2947                                     AC_VERB_SET_POWER_STATE, parm);
2948         }
2949
2950         /* PW 3/4/7 (1ch/1dh/23h) */
2951         parm = AC_PWRST_D3;
2952         /* force to D0 for internal Speaker */
2953         set_pin_power_state(codec, 0x1c, &parm);
2954         set_pin_power_state(codec, 0x1d, &parm);
2955         if (is_8ch)
2956                 set_pin_power_state(codec, 0x23, &parm);
2957
2958         /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
2959         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2960                             imux_is_smixer ? AC_PWRST_D0 : parm);
2961         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2962         if (is_8ch) {
2963                 snd_hda_codec_write(codec, 0x25, 0,
2964                                     AC_VERB_SET_POWER_STATE, parm);
2965                 snd_hda_codec_write(codec, 0x27, 0,
2966                                     AC_VERB_SET_POWER_STATE, parm);
2967         } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
2968                 snd_hda_codec_write(codec, 0x25, 0,
2969                                     AC_VERB_SET_POWER_STATE, parm);
2970 }
2971
2972 static int patch_vt1708S(struct hda_codec *codec);
2973 static int patch_vt1708B(struct hda_codec *codec)
2974 {
2975         struct via_spec *spec;
2976         int err;
2977
2978         if (get_codec_type(codec) == VT1708BCE)
2979                 return patch_vt1708S(codec);
2980
2981         /* create a codec specific record */
2982         spec = via_new_spec(codec);
2983         if (spec == NULL)
2984                 return -ENOMEM;
2985
2986         spec->aa_mix_nid = 0x16;
2987
2988         /* automatic parse from the BIOS config */
2989         err = via_parse_auto_config(codec);
2990         if (err < 0) {
2991                 via_free(codec);
2992                 return err;
2993         }
2994
2995         codec->patch_ops = via_patch_ops;
2996
2997         spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;
2998
2999         return 0;
3000 }
3001
3002 /* Patch for VT1708S */
3003 static const struct hda_verb vt1708S_init_verbs[] = {
3004         /* Enable Mic Boost Volume backdoor */
3005         {0x1, 0xf98, 0x1},
3006         /* don't bybass mixer */
3007         {0x1, 0xf88, 0xc0},
3008         { }
3009 };
3010
3011 /* fill out digital output widgets; one for master and one for slave outputs */
3012 static void fill_dig_outs(struct hda_codec *codec)
3013 {
3014         struct via_spec *spec = codec->spec;
3015         int i;
3016
3017         for (i = 0; i < spec->autocfg.dig_outs; i++) {
3018                 hda_nid_t nid;
3019                 int conn;
3020
3021                 nid = spec->autocfg.dig_out_pins[i];
3022                 if (!nid)
3023                         continue;
3024                 conn = snd_hda_get_connections(codec, nid, &nid, 1);
3025                 if (conn < 1)
3026                         continue;
3027                 if (!spec->multiout.dig_out_nid)
3028                         spec->multiout.dig_out_nid = nid;
3029                 else {
3030                         spec->slave_dig_outs[0] = nid;
3031                         break; /* at most two dig outs */
3032                 }
3033         }
3034 }
3035
3036 static void fill_dig_in(struct hda_codec *codec)
3037 {
3038         struct via_spec *spec = codec->spec;
3039         hda_nid_t dig_nid;
3040         int i, err;
3041
3042         if (!spec->autocfg.dig_in_pin)
3043                 return;
3044
3045         dig_nid = codec->start_nid;
3046         for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3047                 unsigned int wcaps = get_wcaps(codec, dig_nid);
3048                 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3049                         continue;
3050                 if (!(wcaps & AC_WCAP_DIGITAL))
3051                         continue;
3052                 if (!(wcaps & AC_WCAP_CONN_LIST))
3053                         continue;
3054                 err = get_connection_index(codec, dig_nid,
3055                                            spec->autocfg.dig_in_pin);
3056                 if (err >= 0) {
3057                         spec->dig_in_nid = dig_nid;
3058                         break;
3059                 }
3060         }
3061 }
3062
3063 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
3064                                int offset, int num_steps, int step_size)
3065 {
3066         snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
3067                                   (offset << AC_AMPCAP_OFFSET_SHIFT) |
3068                                   (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
3069                                   (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
3070                                   (0 << AC_AMPCAP_MUTE_SHIFT));
3071 }
3072
3073 static int patch_vt1708S(struct hda_codec *codec)
3074 {
3075         struct via_spec *spec;
3076         int err;
3077
3078         /* create a codec specific record */
3079         spec = via_new_spec(codec);
3080         if (spec == NULL)
3081                 return -ENOMEM;
3082
3083         spec->aa_mix_nid = 0x16;
3084         override_mic_boost(codec, 0x1a, 0, 3, 40);
3085         override_mic_boost(codec, 0x1e, 0, 3, 40);
3086
3087         /* automatic parse from the BIOS config */
3088         err = via_parse_auto_config(codec);