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