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 <sound/core.h>
  53 #include <sound/asoundef.h>
  54 #include "hda_codec.h"
  55 #include "hda_local.h"
  56
  57 /* Pin Widget NID */
  58 #define VT1708_HP_PIN_NID       0x20
  59 #define VT1708_CD_PIN_NID       0x24
  60
  61 enum VIA_HDA_CODEC {
  62         UNKNOWN = -1,
  63         VT1708,
  64         VT1709_10CH,
  65         VT1709_6CH,
  66         VT1708B_8CH,
  67         VT1708B_4CH,
  68         VT1708S,
  69         VT1708BCE,
  70         VT1702,
  71         VT1718S,
  72         VT1716S,
  73         VT2002P,
  74         VT1812,
  75         VT1802,
  76         CODEC_TYPES,
  77 };
  78
  79 #define VT2002P_COMPATIBLE(spec) \
  80         ((spec)->codec_type == VT2002P ||\
  81          (spec)->codec_type == VT1812 ||\
  82          (spec)->codec_type == VT1802)
  83
  84 #define MAX_NID_PATH_DEPTH      5
  85
  86 /* output-path: DAC -> ... -> pin
  87  * idx[] contains the source index number of the next widget;
  88  * e.g. idx[0] is the index of the DAC selected by path[1] widget
  89  * multi[] indicates whether it's a selector widget with multi-connectors
  90  * (i.e. the connection selection is mandatory)
  91  * vol_ctl and mute_ctl contains the NIDs for the assigned mixers
  92  */
  93 struct nid_path {
  94         int depth;
  95         hda_nid_t path[MAX_NID_PATH_DEPTH];
  96         unsigned char idx[MAX_NID_PATH_DEPTH];
  97         unsigned char multi[MAX_NID_PATH_DEPTH];
  98         unsigned int vol_ctl;
  99         unsigned int mute_ctl;
 100 };
 101
 102 /* input-path */
 103 struct via_input {
 104         hda_nid_t pin;  /* input-pin or aa-mix */
 105         int adc_idx;    /* ADC index to be used */
 106         int mux_idx;    /* MUX index (if any) */
 107         const char *label;      /* input-source label */
 108 };
 109
 110 #define VIA_MAX_ADCS    3
 111
 112 enum {
 113         STREAM_MULTI_OUT = (1 << 0),
 114         STREAM_INDEP_HP = (1 << 1),
 115 };
 116
 117 struct via_spec {
 118         /* codec parameterization */
 119         const struct snd_kcontrol_new *mixers[6];
 120         unsigned int num_mixers;
 121
 122         const struct hda_verb *init_verbs[5];
 123         unsigned int num_iverbs;
 124
 125         char stream_name_analog[32];
 126         char stream_name_hp[32];
 127         const struct hda_pcm_stream *stream_analog_playback;
 128         const struct hda_pcm_stream *stream_analog_capture;
 129
 130         char stream_name_digital[32];
 131         const struct hda_pcm_stream *stream_digital_playback;
 132         const struct hda_pcm_stream *stream_digital_capture;
 133
 134         /* playback */
 135         struct hda_multi_out multiout;
 136         hda_nid_t slave_dig_outs[2];
 137         hda_nid_t hp_dac_nid;
 138         hda_nid_t speaker_dac_nid;
 139         int hp_indep_shared;    /* indep HP-DAC is shared with side ch */
 140         int opened_streams;     /* STREAM_* bits */
 141         int active_streams;     /* STREAM_* bits */
 142         int aamix_mode;         /* loopback is enabled for output-path? */
 143
 144         /* Output-paths:
 145          * There are different output-paths depending on the setup.
 146          * out_path, hp_path and speaker_path are primary paths.  If both
 147          * direct DAC and aa-loopback routes are available, these contain
 148          * the former paths.  Meanwhile *_mix_path contain the paths with
 149          * loopback mixer.  (Since the loopback is only for front channel,
 150          * no out_mix_path for surround channels.)
 151          * The HP output has another path, hp_indep_path, which is used in
 152          * the independent-HP mode.
 153          */
 154         struct nid_path out_path[HDA_SIDE + 1];
 155         struct nid_path out_mix_path;
 156         struct nid_path hp_path;
 157         struct nid_path hp_mix_path;
 158         struct nid_path hp_indep_path;
 159         struct nid_path speaker_path;
 160         struct nid_path speaker_mix_path;
 161
 162         /* capture */
 163         unsigned int num_adc_nids;
 164         hda_nid_t adc_nids[VIA_MAX_ADCS];
 165         hda_nid_t mux_nids[VIA_MAX_ADCS];
 166         hda_nid_t aa_mix_nid;
 167         hda_nid_t dig_in_nid;
 168
 169         /* capture source */
 170         bool dyn_adc_switch;
 171         int num_inputs;
 172         struct via_input inputs[AUTO_CFG_MAX_INS + 1];
 173         unsigned int cur_mux[VIA_MAX_ADCS];
 174
 175         /* dynamic DAC switching */
 176         unsigned int cur_dac_stream_tag;
 177         unsigned int cur_dac_format;
 178         unsigned int cur_hp_stream_tag;
 179         unsigned int cur_hp_format;
 180
 181         /* dynamic ADC switching */
 182         hda_nid_t cur_adc;
 183         unsigned int cur_adc_stream_tag;
 184         unsigned int cur_adc_format;
 185
 186         /* PCM information */
 187         struct hda_pcm pcm_rec[3];
 188
 189         /* dynamic controls, init_verbs and input_mux */
 190         struct auto_pin_cfg autocfg;
 191         struct snd_array kctls;
 192         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 193
 194         /* HP mode source */
 195         unsigned int hp_independent_mode;
 196         unsigned int dmic_enabled;
 197         unsigned int no_pin_power_ctl;
 198         enum VIA_HDA_CODEC codec_type;
 199
 200         /* smart51 setup */
 201         unsigned int smart51_nums;
 202         hda_nid_t smart51_pins[2];
 203         int smart51_idxs[2];
 204         const char *smart51_labels[2];
 205         unsigned int smart51_enabled;
 206
 207         /* work to check hp jack state */
 208         struct hda_codec *codec;
 209         struct delayed_work vt1708_hp_work;
 210         int vt1708_jack_detect;
 211         int vt1708_hp_present;
 212
 213         void (*set_widgets_power_state)(struct hda_codec *codec);
 214
 215         struct hda_loopback_check loopback;
 216         int num_loopbacks;
 217         struct hda_amp_list loopback_list[8];
 218
 219         /* bind capture-volume */
 220         struct hda_bind_ctls *bind_cap_vol;
 221         struct hda_bind_ctls *bind_cap_sw;
 222
 223         struct mutex config_mutex;
 224 };
 225
 226 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec);
 227 static struct via_spec * via_new_spec(struct hda_codec *codec)
 228 {
 229         struct via_spec *spec;
 230
 231         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 232         if (spec == NULL)
 233                 return NULL;
 234
 235         mutex_init(&spec->config_mutex);
 236         codec->spec = spec;
 237         spec->codec = codec;
 238         spec->codec_type = get_codec_type(codec);
 239         /* VT1708BCE & VT1708S are almost same */
 240         if (spec->codec_type == VT1708BCE)
 241                 spec->codec_type = VT1708S;
 242         return spec;
 243 }
 244
 245 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
 246 {
 247         u32 vendor_id = codec->vendor_id;
 248         u16 ven_id = vendor_id >> 16;
 249         u16 dev_id = vendor_id & 0xffff;
 250         enum VIA_HDA_CODEC codec_type;
 251
 252         /* get codec type */
 253         if (ven_id != 0x1106)
 254                 codec_type = UNKNOWN;
 255         else if (dev_id >= 0x1708 && dev_id <= 0x170b)
 256                 codec_type = VT1708;
 257         else if (dev_id >= 0xe710 && dev_id <= 0xe713)
 258                 codec_type = VT1709_10CH;
 259         else if (dev_id >= 0xe714 && dev_id <= 0xe717)
 260                 codec_type = VT1709_6CH;
 261         else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
 262                 codec_type = VT1708B_8CH;
 263                 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
 264                         codec_type = VT1708BCE;
 265         } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
 266                 codec_type = VT1708B_4CH;
 267         else if ((dev_id & 0xfff) == 0x397
 268                  && (dev_id >> 12) < 8)
 269                 codec_type = VT1708S;
 270         else if ((dev_id & 0xfff) == 0x398
 271                  && (dev_id >> 12) < 8)
 272                 codec_type = VT1702;
 273         else if ((dev_id & 0xfff) == 0x428
 274                  && (dev_id >> 12) < 8)
 275                 codec_type = VT1718S;
 276         else if (dev_id == 0x0433 || dev_id == 0xa721)
 277                 codec_type = VT1716S;
 278         else if (dev_id == 0x0441 || dev_id == 0x4441)
 279                 codec_type = VT1718S;
 280         else if (dev_id == 0x0438 || dev_id == 0x4438)
 281                 codec_type = VT2002P;
 282         else if (dev_id == 0x0448)
 283                 codec_type = VT1812;
 284         else if (dev_id == 0x0440)
 285                 codec_type = VT1708S;
 286         else if ((dev_id & 0xfff) == 0x446)
 287                 codec_type = VT1802;
 288         else
 289                 codec_type = UNKNOWN;
 290         return codec_type;
 291 };
 292
 293 #define VIA_JACK_EVENT          0x20
 294 #define VIA_HP_EVENT            0x01
 295 #define VIA_GPIO_EVENT          0x02
 296 #define VIA_LINE_EVENT          0x03
 297
 298 enum {
 299         VIA_CTL_WIDGET_VOL,
 300         VIA_CTL_WIDGET_MUTE,
 301         VIA_CTL_WIDGET_ANALOG_MUTE,
 302 };
 303
 304 static void analog_low_current_mode(struct hda_codec *codec);
 305 static bool is_aa_path_mute(struct hda_codec *codec);
 306
 307 static void vt1708_start_hp_work(struct via_spec *spec)
 308 {
 309         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
 310                 return;
 311         snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
 312                             !spec->vt1708_jack_detect);
 313         if (!delayed_work_pending(&spec->vt1708_hp_work))
 314                 schedule_delayed_work(&spec->vt1708_hp_work,
 315                                       msecs_to_jiffies(100));
 316 }
 317
 318 static void vt1708_stop_hp_work(struct via_spec *spec)
 319 {
 320         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
 321                 return;
 322         if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
 323             && !is_aa_path_mute(spec->codec))
 324                 return;
 325         snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
 326                             !spec->vt1708_jack_detect);
 327         cancel_delayed_work_sync(&spec->vt1708_hp_work);
 328 }
 329
 330 static void set_widgets_power_state(struct hda_codec *codec)
 331 {
 332         struct via_spec *spec = codec->spec;
 333         if (spec->set_widgets_power_state)
 334                 spec->set_widgets_power_state(codec);
 335 }
 336
 337 static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
 338                                    struct snd_ctl_elem_value *ucontrol)
 339 {
 340         int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
 341         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 342
 343         set_widgets_power_state(codec);
 344         analog_low_current_mode(snd_kcontrol_chip(kcontrol));
 345         if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
 346                 if (is_aa_path_mute(codec))
 347                         vt1708_start_hp_work(codec->spec);
 348                 else
 349                         vt1708_stop_hp_work(codec->spec);
 350         }
 351         return change;
 352 }
 353
 354 /* modify .put = snd_hda_mixer_amp_switch_put */
 355 #define ANALOG_INPUT_MUTE                                               \
 356         {               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
 357                         .name = NULL,                                   \
 358                         .index = 0,                                     \
 359                         .info = snd_hda_mixer_amp_switch_info,          \
 360                         .get = snd_hda_mixer_amp_switch_get,            \
 361                         .put = analog_input_switch_put,                 \
 362                         .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
 363
 364 static const struct snd_kcontrol_new via_control_templates[] = {
 365         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
 366         HDA_CODEC_MUTE(NULL, 0, 0, 0),
 367         ANALOG_INPUT_MUTE,
 368 };
 369
 370
 371 /* add dynamic controls */
 372 static struct snd_kcontrol_new *__via_clone_ctl(struct via_spec *spec,
 373                                 const struct snd_kcontrol_new *tmpl,
 374                                 const char *name)
 375 {
 376         struct snd_kcontrol_new *knew;
 377
 378         snd_array_init(&spec->kctls, sizeof(*knew), 32);
 379         knew = snd_array_new(&spec->kctls);
 380         if (!knew)
 381                 return NULL;
 382         *knew = *tmpl;
 383         if (!name)
 384                 name = tmpl->name;
 385         if (name) {
 386                 knew->name = kstrdup(name, GFP_KERNEL);
 387                 if (!knew->name)
 388                         return NULL;
 389         }
 390         return knew;
 391 }
 392
 393 static int __via_add_control(struct via_spec *spec, int type, const char *name,
 394                              int idx, unsigned long val)
 395 {
 396         struct snd_kcontrol_new *knew;
 397
 398         knew = __via_clone_ctl(spec, &via_control_templates[type], name);
 399         if (!knew)
 400                 return -ENOMEM;
 401         knew->index = idx;
 402         if (get_amp_nid_(val))
 403                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
 404         knew->private_value = val;
 405         return 0;
 406 }
 407
 408 #define via_add_control(spec, type, name, val) \
 409         __via_add_control(spec, type, name, 0, val)
 410
 411 #define via_clone_control(spec, tmpl) __via_clone_ctl(spec, tmpl, NULL)
 412
 413 static void via_free_kctls(struct hda_codec *codec)
 414 {
 415         struct via_spec *spec = codec->spec;
 416
 417         if (spec->kctls.list) {
 418                 struct snd_kcontrol_new *kctl = spec->kctls.list;
 419                 int i;
 420                 for (i = 0; i < spec->kctls.used; i++)
 421                         kfree(kctl[i].name);
 422         }
 423         snd_array_free(&spec->kctls);
 424 }
 425
 426 /* create input playback/capture controls for the given pin */
 427 static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
 428                                 int type_idx, int idx, int mix_nid)
 429 {
 430         char name[32];
 431         int err;
 432
 433         sprintf(name, "%s Playback Volume", ctlname);
 434         err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx,
 435                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 436         if (err < 0)
 437                 return err;
 438         sprintf(name, "%s Playback Switch", ctlname);
 439         err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx,
 440                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 441         if (err < 0)
 442                 return err;
 443         return 0;
 444 }
 445
 446 #define get_connection_index(codec, mux, nid) \
 447         snd_hda_get_conn_index(codec, mux, nid, 0)
 448
 449 static bool check_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir,
 450                            unsigned int mask)
 451 {
 452         unsigned int caps;
 453         if (!nid)
 454                 return false;
 455         caps = get_wcaps(codec, nid);
 456         if (dir == HDA_INPUT)
 457                 caps &= AC_WCAP_IN_AMP;
 458         else
 459                 caps &= AC_WCAP_OUT_AMP;
 460         if (!caps)
 461                 return false;
 462         if (query_amp_caps(codec, nid, dir) & mask)
 463                 return true;
 464         return false;
 465 }
 466
 467 #define have_mute(codec, nid, dir) \
 468         check_amp_caps(codec, nid, dir, AC_AMPCAP_MUTE)
 469
 470 /* enable/disable the output-route mixers */
 471 static void activate_output_mix(struct hda_codec *codec, struct nid_path *path,
 472                                 hda_nid_t mix_nid, int idx, bool enable)
 473 {
 474         int i, num, val;
 475
 476         if (!path)
 477                 return;
 478         num = snd_hda_get_conn_list(codec, mix_nid, NULL);
 479         for (i = 0; i < num; i++) {
 480                 if (i == idx)
 481                         val = AMP_IN_UNMUTE(i);
 482                 else
 483                         val = AMP_IN_MUTE(i);
 484                 snd_hda_codec_write(codec, mix_nid, 0,
 485                                     AC_VERB_SET_AMP_GAIN_MUTE, val);
 486         }
 487 }
 488
 489 /* enable/disable the output-route */
 490 static void activate_output_path(struct hda_codec *codec, struct nid_path *path,
 491                                  bool enable, bool force)
 492 {
 493         struct via_spec *spec = codec->spec;
 494         int i;
 495         for (i = 0; i < path->depth; i++) {
 496                 hda_nid_t src, dst;
 497                 int idx = path->idx[i];
 498                 src = path->path[i];
 499                 if (i < path->depth - 1)
 500                         dst = path->path[i + 1];
 501                 else
 502                         dst = 0;
 503                 if (enable && path->multi[i])
 504                         snd_hda_codec_write(codec, dst, 0,
 505                                             AC_VERB_SET_CONNECT_SEL, idx);
 506                 if (!force && (dst == spec->aa_mix_nid))
 507                         continue;
 508                 if (have_mute(codec, dst, HDA_INPUT))
 509                         activate_output_mix(codec, path, dst, idx, enable);
 510                 if (!force && (src == path->vol_ctl || src == path->mute_ctl))
 511                         continue;
 512                 if (have_mute(codec, src, HDA_OUTPUT)) {
 513                         int val = enable ? AMP_OUT_UNMUTE : AMP_OUT_MUTE;
 514                         snd_hda_codec_write(codec, src, 0,
 515                                             AC_VERB_SET_AMP_GAIN_MUTE, val);
 516                 }
 517         }
 518 }
 519
 520 /* set the given pin as output */
 521 static void init_output_pin(struct hda_codec *codec, hda_nid_t pin,
 522                             int pin_type)
 523 {
 524         if (!pin)
 525                 return;
 526         snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 527                             pin_type);
 528         if (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_EAPD)
 529                 snd_hda_codec_write(codec, pin, 0,
 530                                     AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 531 }
 532
 533 static void via_auto_init_output(struct hda_codec *codec,
 534                                  struct nid_path *path, int pin_type)
 535 {
 536         unsigned int caps;
 537         hda_nid_t pin;
 538
 539         if (!path->depth)
 540                 return;
 541         pin = path->path[path->depth - 1];
 542
 543         init_output_pin(codec, pin, pin_type);
 544         caps = query_amp_caps(codec, pin, HDA_OUTPUT);
 545         if (caps & AC_AMPCAP_MUTE) {
 546                 unsigned int val;
 547                 val = (caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT;
 548                 snd_hda_codec_write(codec, pin, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 549                                     AMP_OUT_MUTE | val);
 550         }
 551         activate_output_path(codec, path, true, true); /* force on */
 552 }
 553
 554 static void via_auto_init_multi_out(struct hda_codec *codec)
 555 {
 556         struct via_spec *spec = codec->spec;
 557         struct nid_path *path;
 558         int i;
 559
 560         for (i = 0; i < spec->autocfg.line_outs + spec->smart51_nums; i++) {
 561                 path = &spec->out_path[i];
 562                 if (!i && spec->aamix_mode && spec->out_mix_path.depth)
 563                         path = &spec->out_mix_path;
 564                 via_auto_init_output(codec, path, PIN_OUT);
 565         }
 566 }
 567
 568 /* deactivate the inactive headphone-paths */
 569 static void deactivate_hp_paths(struct hda_codec *codec)
 570 {
 571         struct via_spec *spec = codec->spec;
 572         int shared = spec->hp_indep_shared;
 573
 574         if (spec->hp_independent_mode) {
 575                 activate_output_path(codec, &spec->hp_path, false, false);
 576                 activate_output_path(codec, &spec->hp_mix_path, false, false);
 577                 if (shared)
 578                         activate_output_path(codec, &spec->out_path[shared],
 579                                              false, false);
 580         } else if (spec->aamix_mode || !spec->hp_path.depth) {
 581                 activate_output_path(codec, &spec->hp_indep_path, false, false);
 582                 activate_output_path(codec, &spec->hp_path, false, false);
 583         } else {
 584                 activate_output_path(codec, &spec->hp_indep_path, false, false);
 585                 activate_output_path(codec, &spec->hp_mix_path, false, false);
 586         }
 587 }
 588
 589 static void via_auto_init_hp_out(struct hda_codec *codec)
 590 {
 591         struct via_spec *spec = codec->spec;
 592
 593         if (!spec->hp_path.depth) {
 594                 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP);
 595                 return;
 596         }
 597         deactivate_hp_paths(codec);
 598         if (spec->hp_independent_mode)
 599                 via_auto_init_output(codec, &spec->hp_indep_path, PIN_HP);
 600         else if (spec->aamix_mode)
 601                 via_auto_init_output(codec, &spec->hp_mix_path, PIN_HP);
 602         else
 603                 via_auto_init_output(codec, &spec->hp_path, PIN_HP);
 604 }
 605
 606 static void via_auto_init_speaker_out(struct hda_codec *codec)
 607 {
 608         struct via_spec *spec = codec->spec;
 609
 610         if (!spec->autocfg.speaker_outs)
 611                 return;
 612         if (!spec->speaker_path.depth) {
 613                 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT);
 614                 return;
 615         }
 616         if (!spec->aamix_mode) {
 617                 activate_output_path(codec, &spec->speaker_mix_path,
 618                                      false, false);
 619                 via_auto_init_output(codec, &spec->speaker_path, PIN_OUT);
 620         } else {
 621                 activate_output_path(codec, &spec->speaker_path, false, false);
 622                 via_auto_init_output(codec, &spec->speaker_mix_path, PIN_OUT);
 623         }
 624 }
 625
 626 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin);
 627 static void via_hp_automute(struct hda_codec *codec);
 628
 629 static void via_auto_init_analog_input(struct hda_codec *codec)
 630 {
 631         struct via_spec *spec = codec->spec;
 632         const struct auto_pin_cfg *cfg = &spec->autocfg;
 633         hda_nid_t conn[HDA_MAX_CONNECTIONS];
 634         unsigned int ctl;
 635         int i, num_conns;
 636
 637         /* init ADCs */
 638         for (i = 0; i < spec->num_adc_nids; i++) {
 639                 snd_hda_codec_write(codec, spec->adc_nids[i], 0,
 640                                     AC_VERB_SET_AMP_GAIN_MUTE,
 641                                     AMP_IN_UNMUTE(0));
 642         }
 643
 644         /* init pins */
 645         for (i = 0; i < cfg->num_inputs; i++) {
 646                 hda_nid_t nid = cfg->inputs[i].pin;
 647                 if (spec->smart51_enabled && is_smart51_pins(codec, nid))
 648                         ctl = PIN_OUT;
 649                 else if (cfg->inputs[i].type == AUTO_PIN_MIC)
 650                         ctl = PIN_VREF50;
 651                 else
 652                         ctl = PIN_IN;
 653                 snd_hda_codec_write(codec, nid, 0,
 654                                     AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
 655         }
 656
 657         /* init input-src */
 658         for (i = 0; i < spec->num_adc_nids; i++) {
 659                 int adc_idx = spec->inputs[spec->cur_mux[i]].adc_idx;
 660                 if (spec->mux_nids[adc_idx]) {
 661                         int mux_idx = spec->inputs[spec->cur_mux[i]].mux_idx;
 662                         snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
 663                                             AC_VERB_SET_CONNECT_SEL,
 664                                             mux_idx);
 665                 }
 666                 if (spec->dyn_adc_switch)
 667                         break; /* only one input-src */
 668         }
 669
 670         /* init aa-mixer */
 671         if (!spec->aa_mix_nid)
 672                 return;
 673         num_conns = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
 674                                             ARRAY_SIZE(conn));
 675         for (i = 0; i < num_conns; i++) {
 676                 unsigned int caps = get_wcaps(codec, conn[i]);
 677                 if (get_wcaps_type(caps) == AC_WID_PIN)
 678                         snd_hda_codec_write(codec, spec->aa_mix_nid, 0,
 679                                             AC_VERB_SET_AMP_GAIN_MUTE,
 680                                             AMP_IN_MUTE(i));
 681         }
 682 }
 683
 684 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
 685                                 unsigned int *affected_parm)
 686 {
 687         unsigned parm;
 688         unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
 689         unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
 690                 >> AC_DEFCFG_MISC_SHIFT
 691                 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
 692         struct via_spec *spec = codec->spec;
 693         unsigned present = 0;
 694
 695         no_presence |= spec->no_pin_power_ctl;
 696         if (!no_presence)
 697                 present = snd_hda_jack_detect(codec, nid);
 698         if ((spec->smart51_enabled && is_smart51_pins(codec, nid))
 699             || ((no_presence || present)
 700                 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
 701                 *affected_parm = AC_PWRST_D0; /* if it's connected */
 702                 parm = AC_PWRST_D0;
 703         } else
 704                 parm = AC_PWRST_D3;
 705
 706         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
 707 }
 708
 709 static int via_pin_power_ctl_info(struct snd_kcontrol *kcontrol,
 710                                   struct snd_ctl_elem_info *uinfo)
 711 {
 712         static const char * const texts[] = {
 713                 "Disabled", "Enabled"
 714         };
 715
 716         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 717         uinfo->count = 1;
 718         uinfo->value.enumerated.items = 2;
 719         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
 720                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
 721         strcpy(uinfo->value.enumerated.name,
 722                texts[uinfo->value.enumerated.item]);
 723         return 0;
 724 }
 725
 726 static int via_pin_power_ctl_get(struct snd_kcontrol *kcontrol,
 727                                  struct snd_ctl_elem_value *ucontrol)
 728 {
 729         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 730         struct via_spec *spec = codec->spec;
 731         ucontrol->value.enumerated.item[0] = !spec->no_pin_power_ctl;
 732         return 0;
 733 }
 734
 735 static int via_pin_power_ctl_put(struct snd_kcontrol *kcontrol,
 736                                  struct snd_ctl_elem_value *ucontrol)
 737 {
 738         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 739         struct via_spec *spec = codec->spec;
 740         unsigned int val = !ucontrol->value.enumerated.item[0];
 741
 742         if (val == spec->no_pin_power_ctl)
 743                 return 0;
 744         spec->no_pin_power_ctl = val;
 745         set_widgets_power_state(codec);
 746         return 1;
 747 }
 748
 749 static const struct snd_kcontrol_new via_pin_power_ctl_enum = {
 750         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 751         .name = "Dynamic Power-Control",
 752         .info = via_pin_power_ctl_info,
 753         .get = via_pin_power_ctl_get,
 754         .put = via_pin_power_ctl_put,
 755 };
 756
 757
 758 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
 759                                    struct snd_ctl_elem_info *uinfo)
 760 {
 761         static const char * const texts[] = { "OFF", "ON" };
 762
 763         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 764         uinfo->count = 1;
 765         uinfo->value.enumerated.items = 2;
 766         if (uinfo->value.enumerated.item >= 2)
 767                 uinfo->value.enumerated.item = 1;
 768         strcpy(uinfo->value.enumerated.name,
 769                texts[uinfo->value.enumerated.item]);
 770         return 0;
 771 }
 772
 773 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
 774                                   struct snd_ctl_elem_value *ucontrol)
 775 {
 776         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 777         struct via_spec *spec = codec->spec;
 778
 779         ucontrol->value.enumerated.item[0] = spec->hp_independent_mode;
 780         return 0;
 781 }
 782
 783 /* adjust spec->multiout setup according to the current flags */
 784 static void setup_playback_multi_pcm(struct via_spec *spec)
 785 {
 786         const struct auto_pin_cfg *cfg = &spec->autocfg;
 787         spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
 788         spec->multiout.hp_nid = 0;
 789         if (!spec->hp_independent_mode) {
 790                 if (!spec->hp_indep_shared)
 791                         spec->multiout.hp_nid = spec->hp_dac_nid;
 792         } else {
 793                 if (spec->hp_indep_shared)
 794                         spec->multiout.num_dacs = cfg->line_outs - 1;
 795         }
 796 }
 797
 798 /* update DAC setups according to indep-HP switch;
 799  * this function is called only when indep-HP is modified
 800  */
 801 static void switch_indep_hp_dacs(struct hda_codec *codec)
 802 {
 803         struct via_spec *spec = codec->spec;
 804         int shared = spec->hp_indep_shared;
 805         hda_nid_t shared_dac, hp_dac;
 806
 807         if (!spec->opened_streams)
 808                 return;
 809
 810         shared_dac = shared ? spec->multiout.dac_nids[shared] : 0;
 811         hp_dac = spec->hp_dac_nid;
 812         if (spec->hp_independent_mode) {
 813                 /* switch to indep-HP mode */
 814                 if (spec->active_streams & STREAM_MULTI_OUT) {
 815                         __snd_hda_codec_cleanup_stream(codec, hp_dac, 1);
 816                         __snd_hda_codec_cleanup_stream(codec, shared_dac, 1);
 817                 }
 818                 if (spec->active_streams & STREAM_INDEP_HP)
 819                         snd_hda_codec_setup_stream(codec, hp_dac,
 820                                                    spec->cur_hp_stream_tag, 0,
 821                                                    spec->cur_hp_format);
 822         } else {
 823                 /* back to HP or shared-DAC */
 824                 if (spec->active_streams & STREAM_INDEP_HP)
 825                         __snd_hda_codec_cleanup_stream(codec, hp_dac, 1);
 826                 if (spec->active_streams & STREAM_MULTI_OUT) {
 827                         hda_nid_t dac;
 828                         int ch;
 829                         if (shared_dac) { /* reset mutli-ch DAC */
 830                                 dac = shared_dac;
 831                                 ch = shared * 2;
 832                         } else { /* reset HP DAC */
 833                                 dac = hp_dac;
 834                                 ch = 0;
 835                         }
 836                         snd_hda_codec_setup_stream(codec, dac,
 837                                                    spec->cur_dac_stream_tag, ch,
 838                                                    spec->cur_dac_format);
 839                 }
 840         }
 841         setup_playback_multi_pcm(spec);
 842 }
 843
 844 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
 845                                   struct snd_ctl_elem_value *ucontrol)
 846 {
 847         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 848         struct via_spec *spec = codec->spec;
 849         int cur, shared;
 850
 851         mutex_lock(&spec->config_mutex);
 852         cur = !!ucontrol->value.enumerated.item[0];
 853         if (spec->hp_independent_mode == cur) {
 854                 mutex_unlock(&spec->config_mutex);
 855                 return 0;
 856         }
 857         spec->hp_independent_mode = cur;
 858         shared = spec->hp_indep_shared;
 859         deactivate_hp_paths(codec);
 860         if (cur)
 861                 activate_output_path(codec, &spec->hp_indep_path, true, false);
 862         else {
 863                 if (shared)
 864                         activate_output_path(codec, &spec->out_path[shared],
 865                                              true, false);
 866                 if (spec->aamix_mode || !spec->hp_path.depth)
 867                         activate_output_path(codec, &spec->hp_mix_path,
 868                                              true, false);
 869                 else
 870                         activate_output_path(codec, &spec->hp_path,
 871                                              true, false);
 872         }
 873
 874         switch_indep_hp_dacs(codec);
 875         mutex_unlock(&spec->config_mutex);
 876
 877         /* update jack power state */
 878         set_widgets_power_state(codec);
 879         via_hp_automute(codec);
 880         return 1;
 881 }
 882
 883 static const struct snd_kcontrol_new via_hp_mixer = {
 884         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 885         .name = "Independent HP",
 886         .info = via_independent_hp_info,
 887         .get = via_independent_hp_get,
 888         .put = via_independent_hp_put,
 889 };
 890
 891 static int via_hp_build(struct hda_codec *codec)
 892 {
 893         struct via_spec *spec = codec->spec;
 894         struct snd_kcontrol_new *knew;
 895         hda_nid_t nid;
 896
 897         nid = spec->autocfg.hp_pins[0];
 898         knew = via_clone_control(spec, &via_hp_mixer);
 899         if (knew == NULL)
 900                 return -ENOMEM;
 901
 902         knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
 903
 904         return 0;
 905 }
 906
 907 static void notify_aa_path_ctls(struct hda_codec *codec)
 908 {
 909         struct via_spec *spec = codec->spec;
 910         int i;
 911
 912         for (i = 0; i < spec->smart51_nums; i++) {
 913                 struct snd_kcontrol *ctl;
 914                 struct snd_ctl_elem_id id;
 915                 memset(&id, 0, sizeof(id));
 916                 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 917                 sprintf(id.name, "%s Playback Volume", spec->smart51_labels[i]);
 918                 ctl = snd_hda_find_mixer_ctl(codec, id.name);
 919                 if (ctl)
 920                         snd_ctl_notify(codec->bus->card,
 921                                         SNDRV_CTL_EVENT_MASK_VALUE,
 922                                         &ctl->id);
 923         }
 924 }
 925
 926 static void mute_aa_path(struct hda_codec *codec, int mute)
 927 {
 928         struct via_spec *spec = codec->spec;
 929         int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
 930         int i;
 931
 932         /* check AA path's mute status */
 933         for (i = 0; i < spec->smart51_nums; i++) {
 934                 if (spec->smart51_idxs[i] < 0)
 935                         continue;
 936                 snd_hda_codec_amp_stereo(codec, spec->aa_mix_nid,
 937                                          HDA_INPUT, spec->smart51_idxs[i],
 938                                          HDA_AMP_MUTE, val);
 939         }
 940 }
 941
 942 static bool is_smart51_pins(struct hda_codec *codec, hda_nid_t pin)
 943 {
 944         struct via_spec *spec = codec->spec;
 945         int i;
 946
 947         for (i = 0; i < spec->smart51_nums; i++)
 948                 if (spec->smart51_pins[i] == pin)
 949                         return true;
 950         return false;
 951 }
 952
 953 static int via_smart51_get(struct snd_kcontrol *kcontrol,
 954                            struct snd_ctl_elem_value *ucontrol)
 955 {
 956         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 957         struct via_spec *spec = codec->spec;
 958
 959         *ucontrol->value.integer.value = spec->smart51_enabled;
 960         return 0;
 961 }
 962
 963 static int via_smart51_put(struct snd_kcontrol *kcontrol,
 964                            struct snd_ctl_elem_value *ucontrol)
 965 {
 966         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 967         struct via_spec *spec = codec->spec;
 968         int out_in = *ucontrol->value.integer.value
 969                 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
 970         int i;
 971
 972         for (i = 0; i < spec->smart51_nums; i++) {
 973                 hda_nid_t nid = spec->smart51_pins[i];
 974                 unsigned int parm;
 975
 976                 parm = snd_hda_codec_read(codec, nid, 0,
 977                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 978                 parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
 979                 parm |= out_in;
 980                 snd_hda_codec_write(codec, nid, 0,
 981                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 982                                     parm);
 983                 if (out_in == AC_PINCTL_OUT_EN) {
 984                         mute_aa_path(codec, 1);
 985                         notify_aa_path_ctls(codec);
 986                 }
 987         }
 988         spec->smart51_enabled = *ucontrol->value.integer.value;
 989         set_widgets_power_state(codec);
 990         return 1;
 991 }
 992
 993 static const struct snd_kcontrol_new via_smart51_mixer = {
 994         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 995         .name = "Smart 5.1",
 996         .count = 1,
 997         .info = snd_ctl_boolean_mono_info,
 998         .get = via_smart51_get,
 999         .put = via_smart51_put,
1000 };
1001
1002 static int via_smart51_build(struct hda_codec *codec)
1003 {
1004         struct via_spec *spec = codec->spec;
1005
1006         if (!spec->smart51_nums)
1007                 return 0;
1008         if (!via_clone_control(spec, &via_smart51_mixer))
1009                 return -ENOMEM;
1010         return 0;
1011 }
1012
1013 /* check AA path's mute status */
1014 static bool is_aa_path_mute(struct hda_codec *codec)
1015 {
1016         struct via_spec *spec = codec->spec;
1017         const struct hda_amp_list *p;
1018         int i, ch, v;
1019
1020         for (i = 0; i < spec->num_loopbacks; i++) {
1021                 p = &spec->loopback_list[i];
1022                 for (ch = 0; ch < 2; ch++) {
1023                         v = snd_hda_codec_amp_read(codec, p->nid, ch, p->dir,
1024                                                    p->idx);
1025                         if (!(v & HDA_AMP_MUTE) && v > 0)
1026                                 return false;
1027                 }
1028         }
1029         return true;
1030 }
1031
1032 /* enter/exit analog low-current mode */
1033 static void analog_low_current_mode(struct hda_codec *codec)
1034 {
1035         struct via_spec *spec = codec->spec;
1036         bool enable;
1037         unsigned int verb, parm;
1038
1039         enable = is_aa_path_mute(codec) && (spec->opened_streams != 0);
1040
1041         /* decide low current mode's verb & parameter */
1042         switch (spec->codec_type) {
1043         case VT1708B_8CH:
1044         case VT1708B_4CH:
1045                 verb = 0xf70;
1046                 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
1047                 break;
1048         case VT1708S:
1049         case VT1718S:
1050         case VT1716S:
1051                 verb = 0xf73;
1052                 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
1053                 break;
1054         case VT1702:
1055                 verb = 0xf73;
1056                 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
1057                 break;
1058         case VT2002P:
1059         case VT1812:
1060         case VT1802:
1061                 verb = 0xf93;
1062                 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
1063                 break;
1064         default:
1065                 return;         /* other codecs are not supported */
1066         }
1067         /* send verb */
1068         snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
1069 }
1070
1071 /*
1072  * generic initialization of ADC, input mixers and output mixers
1073  */
1074 static const struct hda_verb vt1708_init_verbs[] = {
1075         /* power down jack detect function */
1076         {0x1, 0xf81, 0x1},
1077         { }
1078 };
1079
1080 static void set_stream_open(struct hda_codec *codec, int bit, bool active)
1081 {
1082         struct via_spec *spec = codec->spec;
1083
1084         if (active)
1085                 spec->opened_streams |= bit;
1086         else
1087                 spec->opened_streams &= ~bit;
1088         analog_low_current_mode(codec);
1089 }
1090
1091 static int via_playback_multi_pcm_open(struct hda_pcm_stream *hinfo,
1092                                  struct hda_codec *codec,
1093                                  struct snd_pcm_substream *substream)
1094 {
1095         struct via_spec *spec = codec->spec;
1096         const struct auto_pin_cfg *cfg = &spec->autocfg;
1097         int err;
1098
1099         spec->multiout.num_dacs = cfg->line_outs + spec->smart51_nums;
1100         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1101         set_stream_open(codec, STREAM_MULTI_OUT, true);
1102         err = snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
1103                                             hinfo);
1104         if (err < 0) {
1105                 set_stream_open(codec, STREAM_MULTI_OUT, false);
1106                 return err;
1107         }
1108         return 0;
1109 }
1110
1111 static int via_playback_multi_pcm_close(struct hda_pcm_stream *hinfo,
1112                                   struct hda_codec *codec,
1113                                   struct snd_pcm_substream *substream)
1114 {
1115         set_stream_open(codec, STREAM_MULTI_OUT, false);
1116         return 0;
1117 }
1118
1119 static int via_playback_hp_pcm_open(struct hda_pcm_stream *hinfo,
1120                                     struct hda_codec *codec,
1121                                     struct snd_pcm_substream *substream)
1122 {
1123         struct via_spec *spec = codec->spec;
1124
1125         if (snd_BUG_ON(!spec->hp_dac_nid))
1126                 return -EINVAL;
1127         set_stream_open(codec, STREAM_INDEP_HP, true);
1128         return 0;
1129 }
1130
1131 static int via_playback_hp_pcm_close(struct hda_pcm_stream *hinfo,
1132                                      struct hda_codec *codec,
1133                                      struct snd_pcm_substream *substream)
1134 {
1135         set_stream_open(codec, STREAM_INDEP_HP, false);
1136         return 0;
1137 }
1138
1139 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
1140                                           struct hda_codec *codec,
1141                                           unsigned int stream_tag,
1142                                           unsigned int format,
1143                                           struct snd_pcm_substream *substream)
1144 {
1145         struct via_spec *spec = codec->spec;
1146
1147         mutex_lock(&spec->config_mutex);
1148         setup_playback_multi_pcm(spec);
1149         snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag,
1150                                          format, substream);
1151         /* remember for dynamic DAC switch with indep-HP */
1152         spec->active_streams |= STREAM_MULTI_OUT;
1153         spec->cur_dac_stream_tag = stream_tag;
1154         spec->cur_dac_format = format;
1155         mutex_unlock(&spec->config_mutex);
1156         vt1708_start_hp_work(spec);
1157         return 0;
1158 }
1159
1160 static int via_playback_hp_pcm_prepare(struct hda_pcm_stream *hinfo,
1161                                        struct hda_codec *codec,
1162                                        unsigned int stream_tag,
1163                                        unsigned int format,
1164                                        struct snd_pcm_substream *substream)
1165 {
1166         struct via_spec *spec = codec->spec;
1167
1168         mutex_lock(&spec->config_mutex);
1169         if (spec->hp_independent_mode)
1170                 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid,
1171                                            stream_tag, 0, format);
1172         spec->active_streams |= STREAM_INDEP_HP;
1173         spec->cur_hp_stream_tag = stream_tag;
1174         spec->cur_hp_format = format;
1175         mutex_unlock(&spec->config_mutex);
1176         vt1708_start_hp_work(spec);
1177         return 0;
1178 }
1179
1180 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
1181                                     struct hda_codec *codec,
1182                                     struct snd_pcm_substream *substream)
1183 {
1184         struct via_spec *spec = codec->spec;
1185
1186         mutex_lock(&spec->config_mutex);
1187         snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
1188         spec->active_streams &= ~STREAM_MULTI_OUT;
1189         mutex_unlock(&spec->config_mutex);
1190         vt1708_stop_hp_work(spec);
1191         return 0;
1192 }
1193
1194 static int via_playback_hp_pcm_cleanup(struct hda_pcm_stream *hinfo,
1195                                        struct hda_codec *codec,
1196                                        struct snd_pcm_substream *substream)
1197 {
1198         struct via_spec *spec = codec->spec;
1199
1200         mutex_lock(&spec->config_mutex);
1201         if (spec->hp_independent_mode)
1202                 snd_hda_codec_setup_stream(codec, spec->hp_dac_nid, 0, 0, 0);
1203         spec->active_streams &= ~STREAM_INDEP_HP;
1204         mutex_unlock(&spec->config_mutex);
1205         vt1708_stop_hp_work(spec);
1206         return 0;
1207 }
1208
1209 /*
1210  * Digital out
1211  */
1212 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1213                                      struct hda_codec *codec,
1214                                      struct snd_pcm_substream *substream)
1215 {
1216         struct via_spec *spec = codec->spec;
1217         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1218 }
1219
1220 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1221                                       struct hda_codec *codec,
1222                                       struct snd_pcm_substream *substream)
1223 {
1224         struct via_spec *spec = codec->spec;
1225         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1226 }
1227
1228 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1229                                         struct hda_codec *codec,
1230                                         unsigned int stream_tag,
1231                                         unsigned int format,
1232                                         struct snd_pcm_substream *substream)
1233 {
1234         struct via_spec *spec = codec->spec;
1235         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1236                                              stream_tag, format, substream);
1237 }
1238
1239 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1240                                         struct hda_codec *codec,
1241                                         struct snd_pcm_substream *substream)
1242 {
1243         struct via_spec *spec = codec->spec;
1244         snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1245         return 0;
1246 }
1247
1248 /*
1249  * Analog capture
1250  */
1251 static int via_capture_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
1259         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1260                                    stream_tag, 0, format);
1261         return 0;
1262 }
1263
1264 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1265                                    struct hda_codec *codec,
1266                                    struct snd_pcm_substream *substream)
1267 {
1268         struct via_spec *spec = codec->spec;
1269         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1270         return 0;
1271 }
1272
1273 /* analog capture with dynamic ADC switching */
1274 static int via_dyn_adc_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         int adc_idx = spec->inputs[spec->cur_mux[0]].adc_idx;
1282
1283         mutex_lock(&spec->config_mutex);
1284         spec->cur_adc = spec->adc_nids[adc_idx];
1285         spec->cur_adc_stream_tag = stream_tag;
1286         spec->cur_adc_format = format;
1287         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
1288         mutex_unlock(&spec->config_mutex);
1289         return 0;
1290 }
1291
1292 static int via_dyn_adc_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1293                                            struct hda_codec *codec,
1294                                            struct snd_pcm_substream *substream)
1295 {
1296         struct via_spec *spec = codec->spec;
1297
1298         mutex_lock(&spec->config_mutex);
1299         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
1300         spec->cur_adc = 0;
1301         mutex_unlock(&spec->config_mutex);
1302         return 0;
1303 }
1304
1305 /* re-setup the stream if running; called from input-src put */
1306 static bool via_dyn_adc_pcm_resetup(struct hda_codec *codec, int cur)
1307 {
1308         struct via_spec *spec = codec->spec;
1309         int adc_idx = spec->inputs[cur].adc_idx;
1310         hda_nid_t adc = spec->adc_nids[adc_idx];
1311         bool ret = false;
1312
1313         mutex_lock(&spec->config_mutex);
1314         if (spec->cur_adc && spec->cur_adc != adc) {
1315                 /* stream is running, let's swap the current ADC */
1316                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1317                 spec->cur_adc = adc;
1318                 snd_hda_codec_setup_stream(codec, adc,
1319                                            spec->cur_adc_stream_tag, 0,
1320                                            spec->cur_adc_format);
1321                 ret = true;
1322         }
1323         mutex_unlock(&spec->config_mutex);
1324         return ret;
1325 }
1326
1327 static const struct hda_pcm_stream via_pcm_analog_playback = {
1328         .substreams = 1,
1329         .channels_min = 2,
1330         .channels_max = 8,
1331         /* NID is set in via_build_pcms */
1332         .ops = {
1333                 .open = via_playback_multi_pcm_open,
1334                 .close = via_playback_multi_pcm_close,
1335                 .prepare = via_playback_multi_pcm_prepare,
1336                 .cleanup = via_playback_multi_pcm_cleanup
1337         },
1338 };
1339
1340 static const struct hda_pcm_stream via_pcm_hp_playback = {
1341         .substreams = 1,
1342         .channels_min = 2,
1343         .channels_max = 2,
1344         /* NID is set in via_build_pcms */
1345         .ops = {
1346                 .open = via_playback_hp_pcm_open,
1347                 .close = via_playback_hp_pcm_close,
1348                 .prepare = via_playback_hp_pcm_prepare,
1349                 .cleanup = via_playback_hp_pcm_cleanup
1350         },
1351 };
1352
1353 static const struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1354         .substreams = 1,
1355         .channels_min = 2,
1356         .channels_max = 8,
1357         /* NID is set in via_build_pcms */
1358         /* We got noisy outputs on the right channel on VT1708 when
1359          * 24bit samples are used.  Until any workaround is found,
1360          * disable the 24bit format, so far.
1361          */
1362         .formats = SNDRV_PCM_FMTBIT_S16_LE,
1363         .ops = {
1364                 .open = via_playback_multi_pcm_open,
1365                 .close = via_playback_multi_pcm_close,
1366                 .prepare = via_playback_multi_pcm_prepare,
1367                 .cleanup = via_playback_multi_pcm_cleanup
1368         },
1369 };
1370
1371 static const struct hda_pcm_stream via_pcm_analog_capture = {
1372         .substreams = 1, /* will be changed in via_build_pcms() */
1373         .channels_min = 2,
1374         .channels_max = 2,
1375         /* NID is set in via_build_pcms */
1376         .ops = {
1377                 .prepare = via_capture_pcm_prepare,
1378                 .cleanup = via_capture_pcm_cleanup
1379         },
1380 };
1381
1382 static const struct hda_pcm_stream via_pcm_dyn_adc_analog_capture = {
1383         .substreams = 1,
1384         .channels_min = 2,
1385         .channels_max = 2,
1386         /* NID is set in via_build_pcms */
1387         .ops = {
1388                 .prepare = via_dyn_adc_capture_pcm_prepare,
1389                 .cleanup = via_dyn_adc_capture_pcm_cleanup,
1390         },
1391 };
1392
1393 static const struct hda_pcm_stream via_pcm_digital_playback = {
1394         .substreams = 1,
1395         .channels_min = 2,
1396         .channels_max = 2,
1397         /* NID is set in via_build_pcms */
1398         .ops = {
1399                 .open = via_dig_playback_pcm_open,
1400                 .close = via_dig_playback_pcm_close,
1401                 .prepare = via_dig_playback_pcm_prepare,
1402                 .cleanup = via_dig_playback_pcm_cleanup
1403         },
1404 };
1405
1406 static const struct hda_pcm_stream via_pcm_digital_capture = {
1407         .substreams = 1,
1408         .channels_min = 2,
1409         .channels_max = 2,
1410 };
1411
1412 /*
1413  * slave controls for virtual master
1414  */
1415 static const char * const via_slave_vols[] = {
1416         "Front Playback Volume",
1417         "Surround Playback Volume",
1418         "Center Playback Volume",
1419         "LFE Playback Volume",
1420         "Side Playback Volume",
1421         "Headphone Playback Volume",
1422         "Speaker Playback Volume",
1423         NULL,
1424 };
1425
1426 static const char * const via_slave_sws[] = {
1427         "Front Playback Switch",
1428         "Surround Playback Switch",
1429         "Center Playback Switch",
1430         "LFE Playback Switch",
1431         "Side Playback Switch",
1432         "Headphone Playback Switch",
1433         "Speaker Playback Switch",
1434         NULL,
1435 };
1436
1437 static int via_build_controls(struct hda_codec *codec)
1438 {
1439         struct via_spec *spec = codec->spec;
1440         struct snd_kcontrol *kctl;
1441         int err, i;
1442
1443         if (spec->set_widgets_power_state)
1444                 if (!via_clone_control(spec, &via_pin_power_ctl_enum))
1445                         return -ENOMEM;
1446
1447         for (i = 0; i < spec->num_mixers; i++) {
1448                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1449                 if (err < 0)
1450                         return err;
1451         }
1452
1453         if (spec->multiout.dig_out_nid) {
1454                 err = snd_hda_create_spdif_out_ctls(codec,
1455                                                     spec->multiout.dig_out_nid,
1456                                                     spec->multiout.dig_out_nid);
1457                 if (err < 0)
1458                         return err;
1459                 err = snd_hda_create_spdif_share_sw(codec,
1460                                                     &spec->multiout);
1461                 if (err < 0)
1462                         return err;
1463                 spec->multiout.share_spdif = 1;
1464         }
1465         if (spec->dig_in_nid) {
1466                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1467                 if (err < 0)
1468                         return err;
1469         }
1470
1471         /* if we have no master control, let's create it */
1472         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1473                 unsigned int vmaster_tlv[4];
1474                 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1475                                         HDA_OUTPUT, vmaster_tlv);
1476                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1477                                           vmaster_tlv, via_slave_vols);
1478                 if (err < 0)
1479                         return err;
1480         }
1481         if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1482                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1483                                           NULL, via_slave_sws);
1484                 if (err < 0)
1485                         return err;
1486         }
1487
1488         /* assign Capture Source enums to NID */
1489         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1490         for (i = 0; kctl && i < kctl->count; i++) {
1491                 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1492                 if (err < 0)
1493                         return err;
1494         }
1495
1496         /* init power states */
1497         set_widgets_power_state(codec);
1498         analog_low_current_mode(codec);
1499
1500         via_free_kctls(codec); /* no longer needed */
1501         return 0;
1502 }
1503
1504 static int via_build_pcms(struct hda_codec *codec)
1505 {
1506         struct via_spec *spec = codec->spec;
1507         struct hda_pcm *info = spec->pcm_rec;
1508
1509         codec->num_pcms = 1;
1510         codec->pcm_info = info;
1511
1512         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
1513                  "%s Analog", codec->chip_name);
1514         info->name = spec->stream_name_analog;
1515
1516         if (!spec->stream_analog_playback)
1517                 spec->stream_analog_playback = &via_pcm_analog_playback;
1518         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1519                 *spec->stream_analog_playback;
1520         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1521                 spec->multiout.dac_nids[0];
1522         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1523                 spec->multiout.max_channels;
1524
1525         if (!spec->stream_analog_capture) {
1526                 if (spec->dyn_adc_switch)
1527                         spec->stream_analog_capture =
1528                                 &via_pcm_dyn_adc_analog_capture;
1529                 else
1530                         spec->stream_analog_capture = &via_pcm_analog_capture;
1531         }
1532         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1533                 *spec->stream_analog_capture;
1534         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1535         if (!spec->dyn_adc_switch)
1536                 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
1537                         spec->num_adc_nids;
1538
1539         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1540                 codec->num_pcms++;
1541                 info++;
1542                 snprintf(spec->stream_name_digital,
1543                          sizeof(spec->stream_name_digital),
1544                          "%s Digital", codec->chip_name);
1545                 info->name = spec->stream_name_digital;
1546                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1547                 if (spec->multiout.dig_out_nid) {
1548                         if (!spec->stream_digital_playback)
1549                                 spec->stream_digital_playback =
1550                                         &via_pcm_digital_playback;
1551                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1552                                 *spec->stream_digital_playback;
1553                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1554                                 spec->multiout.dig_out_nid;
1555                 }
1556                 if (spec->dig_in_nid) {
1557                         if (!spec->stream_digital_capture)
1558                                 spec->stream_digital_capture =
1559                                         &via_pcm_digital_capture;
1560                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1561                                 *spec->stream_digital_capture;
1562                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1563                                 spec->dig_in_nid;
1564                 }
1565         }
1566
1567         if (spec->hp_dac_nid) {
1568                 codec->num_pcms++;
1569                 info++;
1570                 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
1571                          "%s HP", codec->chip_name);
1572                 info->name = spec->stream_name_hp;
1573                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
1574                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1575                         spec->hp_dac_nid;
1576         }
1577         return 0;
1578 }
1579
1580 static void via_free(struct hda_codec *codec)
1581 {
1582         struct via_spec *spec = codec->spec;
1583
1584         if (!spec)
1585                 return;
1586
1587         via_free_kctls(codec);
1588         vt1708_stop_hp_work(spec);
1589         kfree(spec->bind_cap_vol);
1590         kfree(spec->bind_cap_sw);
1591         kfree(spec);
1592 }
1593
1594 /* mute/unmute outputs */
1595 static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
1596                                 hda_nid_t *pins, bool mute)
1597 {
1598         int i;
1599         for (i = 0; i < num_pins; i++) {
1600                 unsigned int parm = snd_hda_codec_read(codec, pins[i], 0,
1601                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1602                 if (parm & AC_PINCTL_IN_EN)
1603                         continue;
1604                 if (mute)
1605                         parm &= ~AC_PINCTL_OUT_EN;
1606                 else
1607                         parm |= AC_PINCTL_OUT_EN;
1608                 snd_hda_codec_write(codec, pins[i], 0,
1609                                     AC_VERB_SET_PIN_WIDGET_CONTROL, parm);
1610         }
1611 }
1612
1613 /* mute internal speaker if line-out is plugged */
1614 static void via_line_automute(struct hda_codec *codec, int present)
1615 {
1616         struct via_spec *spec = codec->spec;
1617
1618         if (!spec->autocfg.speaker_outs)
1619                 return;
1620         if (!present)
1621                 present = snd_hda_jack_detect(codec,
1622                                               spec->autocfg.line_out_pins[0]);
1623         toggle_output_mutes(codec, spec->autocfg.speaker_outs,
1624                             spec->autocfg.speaker_pins,
1625                             present);
1626 }
1627
1628 /* mute internal speaker if HP is plugged */
1629 static void via_hp_automute(struct hda_codec *codec)
1630 {
1631         int present = 0;
1632         int nums;
1633         struct via_spec *spec = codec->spec;
1634
1635         if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0])
1636                 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1637
1638         if (spec->smart51_enabled)
1639                 nums = spec->autocfg.line_outs + spec->smart51_nums;
1640         else
1641                 nums = spec->autocfg.line_outs;
1642         toggle_output_mutes(codec, nums, spec->autocfg.line_out_pins, present);
1643
1644         via_line_automute(codec, present);
1645 }
1646
1647 static void via_gpio_control(struct hda_codec *codec)
1648 {
1649         unsigned int gpio_data;
1650         unsigned int vol_counter;
1651         unsigned int vol;
1652         unsigned int master_vol;
1653
1654         struct via_spec *spec = codec->spec;
1655
1656         gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
1657                                        AC_VERB_GET_GPIO_DATA, 0) & 0x03;
1658
1659         vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
1660                                           0xF84, 0) & 0x3F0000) >> 16;
1661
1662         vol = vol_counter & 0x1F;
1663         master_vol = snd_hda_codec_read(codec, 0x1A, 0,
1664                                         AC_VERB_GET_AMP_GAIN_MUTE,
1665                                         AC_AMP_GET_INPUT);
1666
1667         if (gpio_data == 0x02) {
1668                 /* unmute line out */
1669                 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1670                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1671                                     PIN_OUT);
1672                 if (vol_counter & 0x20) {
1673                         /* decrease volume */
1674                         if (vol > master_vol)
1675                                 vol = master_vol;
1676                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1677                                                  0, HDA_AMP_VOLMASK,
1678                                                  master_vol-vol);
1679                 } else {
1680                         /* increase volume */
1681                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1682                                          HDA_AMP_VOLMASK,
1683                                          ((master_vol+vol) > 0x2A) ? 0x2A :
1684                                           (master_vol+vol));
1685                 }
1686         } else if (!(gpio_data & 0x02)) {
1687                 /* mute line out */
1688                 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1689                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1690                                     0);
1691         }
1692 }
1693
1694 /* unsolicited event for jack sensing */
1695 static void via_unsol_event(struct hda_codec *codec,
1696                                   unsigned int res)
1697 {
1698         res >>= 26;
1699
1700         if (res & VIA_JACK_EVENT)
1701                 set_widgets_power_state(codec);
1702
1703         res &= ~VIA_JACK_EVENT;
1704
1705         if (res == VIA_HP_EVENT || res == VIA_LINE_EVENT)
1706                 via_hp_automute(codec);
1707         else if (res == VIA_GPIO_EVENT)
1708                 via_gpio_control(codec);
1709 }
1710
1711 #ifdef CONFIG_PM
1712 static int via_suspend(struct hda_codec *codec, pm_message_t state)
1713 {
1714         struct via_spec *spec = codec->spec;
1715         vt1708_stop_hp_work(spec);
1716         return 0;
1717 }
1718 #endif
1719
1720 #ifdef CONFIG_SND_HDA_POWER_SAVE
1721 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1722 {
1723         struct via_spec *spec = codec->spec;
1724         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1725 }
1726 #endif
1727
1728 /*
1729  */
1730
1731 static int via_init(struct hda_codec *codec);
1732
1733 static const struct hda_codec_ops via_patch_ops = {
1734         .build_controls = via_build_controls,
1735         .build_pcms = via_build_pcms,
1736         .init = via_init,
1737         .free = via_free,
1738         .unsol_event = via_unsol_event,
1739 #ifdef CONFIG_PM
1740         .suspend = via_suspend,
1741 #endif
1742 #ifdef CONFIG_SND_HDA_POWER_SAVE
1743         .check_power_status = via_check_power_status,
1744 #endif
1745 };
1746
1747 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
1748 {
1749         struct via_spec *spec = codec->spec;
1750         int i;
1751
1752         for (i = 0; i < spec->multiout.num_dacs; i++) {
1753                 if (spec->multiout.dac_nids[i] == dac)
1754                         return false;
1755         }
1756         if (spec->hp_dac_nid == dac)
1757                 return false;
1758         return true;
1759 }
1760
1761 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1762                                 hda_nid_t target_dac, int with_aa_mix,
1763                                 struct nid_path *path, int depth)
1764 {
1765         struct via_spec *spec = codec->spec;
1766         hda_nid_t conn[8];
1767         int i, nums;
1768
1769         if (nid == spec->aa_mix_nid) {
1770                 if (!with_aa_mix)
1771                         return false;
1772                 with_aa_mix = 2; /* mark aa-mix is included */
1773         }
1774
1775         nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
1776         for (i = 0; i < nums; i++) {
1777                 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
1778                         continue;
1779                 if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) {
1780                         /* aa-mix is requested but not included? */
1781                         if (!(spec->aa_mix_nid && with_aa_mix == 1))
1782                                 goto found;
1783                 }
1784         }
1785         if (depth >= MAX_NID_PATH_DEPTH)
1786                 return false;
1787         for (i = 0; i < nums; i++) {
1788                 unsigned int type;
1789                 type = get_wcaps_type(get_wcaps(codec, conn[i]));
1790                 if (type == AC_WID_AUD_OUT)
1791                         continue;
1792                 if (__parse_output_path(codec, conn[i], target_dac,
1793                                         with_aa_mix, path, depth + 1))
1794                         goto found;
1795         }
1796         return false;
1797
1798  found:
1799         path->path[path->depth] = conn[i];
1800         path->idx[path->depth] = i;
1801         if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
1802                 path->multi[path->depth] = 1;
1803         path->depth++;
1804         return true;
1805 }
1806
1807 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1808                               hda_nid_t target_dac, int with_aa_mix,
1809                               struct nid_path *path)
1810 {
1811         if (__parse_output_path(codec, nid, target_dac, with_aa_mix, path, 1)) {
1812                 path->path[path->depth] = nid;
1813                 path->depth++;
1814                 snd_printdd("output-path: depth=%d, %02x/%02x/%02x/%02x/%02x\n",
1815                             path->depth, path->path[0], path->path[1],
1816                             path->path[2], path->path[3], path->path[4]);
1817                 return true;
1818         }
1819         return false;
1820 }
1821
1822 static int via_auto_fill_dac_nids(struct hda_codec *codec)
1823 {
1824         struct via_spec *spec = codec->spec;
1825         const struct auto_pin_cfg *cfg = &spec->autocfg;
1826         int i, dac_num;
1827         hda_nid_t nid;
1828
1829         spec->multiout.dac_nids = spec->private_dac_nids;
1830         dac_num = 0;
1831         for (i = 0; i < cfg->line_outs; i++) {
1832                 hda_nid_t dac = 0;
1833                 nid = cfg->line_out_pins[i];
1834                 if (!nid)
1835                         continue;
1836                 if (parse_output_path(codec, nid, 0, 0, &spec->out_path[i]))
1837                         dac = spec->out_path[i].path[0];
1838                 if (!i && parse_output_path(codec, nid, dac, 1,
1839                                             &spec->out_mix_path))
1840                         dac = spec->out_mix_path.path[0];
1841                 if (dac) {
1842                         spec->private_dac_nids[i] = dac;
1843                         dac_num++;
1844                 }
1845         }
1846         if (!spec->out_path[0].depth && spec->out_mix_path.depth) {
1847                 spec->out_path[0] = spec->out_mix_path;
1848                 spec->out_mix_path.depth = 0;
1849         }
1850         spec->multiout.num_dacs = dac_num;
1851         return 0;
1852 }
1853
1854 static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1855                           int chs, bool check_dac, struct nid_path *path)
1856 {
1857         struct via_spec *spec = codec->spec;
1858         char name[32];
1859         hda_nid_t dac, pin, sel, nid;
1860         int err;
1861
1862         dac = check_dac ? path->path[0] : 0;
1863         pin = path->path[path->depth - 1];
1864         sel = path->depth > 1 ? path->path[1] : 0;
1865
1866         if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1867                 nid = dac;
1868         else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1869                 nid = pin;
1870         else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1871                 nid = sel;
1872         else
1873                 nid = 0;
1874         if (nid) {
1875                 sprintf(name, "%s Playback Volume", pfx);
1876                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1877                               HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1878                 if (err < 0)
1879                         return err;
1880                 path->vol_ctl = nid;
1881         }
1882
1883         if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1884                 nid = dac;
1885         else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1886                 nid = pin;
1887         else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE))
1888                 nid = sel;
1889         else
1890                 nid = 0;
1891         if (nid) {
1892                 sprintf(name, "%s Playback Switch", pfx);
1893                 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1894                               HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1895                 if (err < 0)
1896                         return err;
1897                 path->mute_ctl = nid;
1898         }
1899         return 0;
1900 }
1901
1902 static void mangle_smart51(struct hda_codec *codec)
1903 {
1904         struct via_spec *spec = codec->spec;
1905         struct auto_pin_cfg *cfg = &spec->autocfg;
1906         struct auto_pin_cfg_item *ins = cfg->inputs;
1907         int i, j, nums, attr;
1908         int pins[AUTO_CFG_MAX_INS];
1909
1910         for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
1911                 nums = 0;
1912                 for (i = 0; i < cfg->num_inputs; i++) {
1913                         unsigned int def;
1914                         if (ins[i].type > AUTO_PIN_LINE_IN)
1915                                 continue;
1916                         def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
1917                         if (snd_hda_get_input_pin_attr(def) != attr)
1918                                 continue;
1919                         for (j = 0; j < nums; j++)
1920                                 if (ins[pins[j]].type < ins[i].type) {
1921                                         memmove(pins + j + 1, pins + j,
1922                                                 (nums - j) * sizeof(int));
1923                                         break;
1924                                 }
1925                         pins[j] = i;
1926                         nums++;
1927                 }
1928                 if (cfg->line_outs + nums < 3)
1929                         continue;
1930                 for (i = 0; i < nums; i++) {
1931                         hda_nid_t pin = ins[pins[i]].pin;
1932                         spec->smart51_pins[spec->smart51_nums++] = pin;
1933                         cfg->line_out_pins[cfg->line_outs++] = pin;
1934                         if (cfg->line_outs == 3)
1935                                 break;
1936                 }
1937                 return;
1938         }
1939 }
1940
1941 static void copy_path_mixer_ctls(struct nid_path *dst, struct nid_path *src)
1942 {
1943         dst->vol_ctl = src->vol_ctl;
1944         dst->mute_ctl = src->mute_ctl;
1945 }
1946
1947 /* add playback controls from the parsed DAC table */
1948 static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1949 {
1950         struct via_spec *spec = codec->spec;
1951         struct auto_pin_cfg *cfg = &spec->autocfg;
1952         struct nid_path *path;
1953         static const char * const chname[4] = {
1954                 "Front", "Surround", "C/LFE", "Side"
1955         };
1956         int i, idx, err;
1957         int old_line_outs;
1958
1959         /* check smart51 */
1960         old_line_outs = cfg->line_outs;
1961         if (cfg->line_outs == 1)
1962                 mangle_smart51(codec);
1963
1964         err = via_auto_fill_dac_nids(codec);
1965         if (err < 0)
1966                 return err;
1967
1968         if (spec->multiout.num_dacs < 3) {
1969                 spec->smart51_nums = 0;
1970                 cfg->line_outs = old_line_outs;
1971         }
1972         for (i = 0; i < cfg->line_outs; i++) {
1973                 hda_nid_t pin, dac;
1974                 pin = cfg->line_out_pins[i];
1975                 dac = spec->multiout.dac_nids[i];
1976                 if (!pin || !dac)
1977                         continue;
1978                 path = spec->out_path + i;
1979                 if (i == HDA_CLFE) {
1980                         err = create_ch_ctls(codec, "Center", 1, true, path);
1981                         if (err < 0)
1982                                 return err;
1983                         err = create_ch_ctls(codec, "LFE", 2, true, path);
1984                         if (err < 0)
1985                                 return err;
1986                 } else {
1987                         const char *pfx = chname[i];
1988                         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
1989                             cfg->line_outs == 1)
1990                                 pfx = "Speaker";
1991                         err = create_ch_ctls(codec, pfx, 3, true, path);
1992                         if (err < 0)
1993                                 return err;
1994                 }
1995                 if (path != spec->out_path + i)
1996                         copy_path_mixer_ctls(&spec->out_path[i], path);
1997                 if (path == spec->out_path && spec->out_mix_path.depth)
1998                         copy_path_mixer_ctls(&spec->out_mix_path, path);
1999         }
2000
2001         idx = get_connection_index(codec, spec->aa_mix_nid,
2002                                    spec->multiout.dac_nids[0]);
2003         if (idx >= 0) {
2004                 /* add control to mixer */
2005                 const char *name;
2006                 name = spec->out_mix_path.depth ?
2007                         "PCM Loopback Playback Volume" : "PCM Playback Volume";
2008                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2009                                       HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2010                                                           idx, HDA_INPUT));
2011                 if (err < 0)
2012                         return err;
2013                 name = spec->out_mix_path.depth ?
2014                         "PCM Loopback Playback Switch" : "PCM Playback Switch";
2015                 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2016                                       HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2017                                                           idx, HDA_INPUT));
2018                 if (err < 0)
2019                         return err;
2020         }
2021
2022         cfg->line_outs = old_line_outs;
2023
2024         return 0;
2025 }
2026
2027 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
2028 {
2029         struct via_spec *spec = codec->spec;
2030         struct nid_path *path;
2031         bool check_dac;
2032         int i, err;
2033
2034         if (!pin)
2035                 return 0;
2036
2037         if (!parse_output_path(codec, pin, 0, 0, &spec->hp_indep_path)) {
2038                 for (i = HDA_SIDE; i >= HDA_CLFE; i--) {
2039                         if (i < spec->multiout.num_dacs &&
2040                             parse_output_path(codec, pin,
2041                                               spec->multiout.dac_nids[i], 0,
2042                                               &spec->hp_indep_path)) {
2043                                 spec->hp_indep_shared = i;
2044                                 break;
2045                         }
2046                 }
2047         }
2048         if (spec->hp_indep_path.depth) {
2049                 spec->hp_dac_nid = spec->hp_indep_path.path[0];
2050                 if (!spec->hp_indep_shared)
2051                         spec->hp_path = spec->hp_indep_path;
2052         }
2053         /* optionally check front-path w/o AA-mix */
2054         if (!spec->hp_path.depth)
2055                 parse_output_path(codec, pin,
2056                                   spec->multiout.dac_nids[HDA_FRONT], 0,
2057                                   &spec->hp_path);
2058
2059         if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2060                                1, &spec->hp_mix_path) && !spec->hp_path.depth)
2061                 return 0;
2062
2063         if (spec->hp_path.depth) {
2064                 path = &spec->hp_path;
2065                 check_dac = true;
2066         } else {
2067                 path = &spec->hp_mix_path;
2068                 check_dac = false;
2069         }
2070         err = create_ch_ctls(codec, "Headphone", 3, check_dac, path);
2071         if (err < 0)
2072                 return err;
2073         if (check_dac)
2074                 copy_path_mixer_ctls(&spec->hp_mix_path, path);
2075         else
2076                 copy_path_mixer_ctls(&spec->hp_path, path);
2077         if (spec->hp_indep_path.depth)
2078                 copy_path_mixer_ctls(&spec->hp_indep_path, path);
2079         return 0;
2080 }
2081
2082 static int via_auto_create_speaker_ctls(struct hda_codec *codec)
2083 {
2084         struct via_spec *spec = codec->spec;
2085         struct nid_path *path;
2086         bool check_dac;
2087         hda_nid_t pin, dac = 0;
2088         int err;
2089
2090         pin = spec->autocfg.speaker_pins[0];
2091         if (!spec->autocfg.speaker_outs || !pin)
2092                 return 0;
2093
2094         if (parse_output_path(codec, pin, 0, 0, &spec->speaker_path))
2095                 dac = spec->speaker_path.path[0];
2096         if (!dac)
2097                 parse_output_path(codec, pin,
2098                                   spec->multiout.dac_nids[HDA_FRONT], 0,
2099                                   &spec->speaker_path);
2100         if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2101                                1, &spec->speaker_mix_path) && !dac)
2102                 return 0;
2103
2104         /* no AA-path for front? */
2105         if (!spec->out_mix_path.depth && spec->speaker_mix_path.depth)
2106                 dac = 0;
2107
2108         spec->speaker_dac_nid = dac;
2109         spec->multiout.extra_out_nid[0] = dac;
2110         if (dac) {
2111                 path = &spec->speaker_path;
2112                 check_dac = true;
2113         } else {
2114                 path = &spec->speaker_mix_path;
2115                 check_dac = false;
2116         }
2117         err = create_ch_ctls(codec, "Speaker", 3, check_dac, path);
2118         if (err < 0)
2119                 return err;
2120         if (check_dac)
2121                 copy_path_mixer_ctls(&spec->speaker_mix_path, path);
2122         else
2123                 copy_path_mixer_ctls(&spec->speaker_path, path);
2124         return 0;
2125 }
2126
2127 #define via_aamix_ctl_info      via_pin_power_ctl_info
2128
2129 static int via_aamix_ctl_get(struct snd_kcontrol *kcontrol,
2130                              struct snd_ctl_elem_value *ucontrol)
2131 {
2132         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2133         struct via_spec *spec = codec->spec;
2134         ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2135         return 0;
2136 }
2137
2138 static void update_aamix_paths(struct hda_codec *codec, int do_mix,
2139                                struct nid_path *nomix, struct nid_path *mix)
2140 {
2141         if (do_mix) {
2142                 activate_output_path(codec, nomix, false, false);
2143                 activate_output_path(codec, mix, true, false);
2144         } else {
2145                 activate_output_path(codec, mix, false, false);
2146                 activate_output_path(codec, nomix, true, false);
2147         }
2148 }
2149
2150 static int via_aamix_ctl_put(struct snd_kcontrol *kcontrol,
2151                              struct snd_ctl_elem_value *ucontrol)
2152 {
2153         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2154         struct via_spec *spec = codec->spec;
2155         unsigned int val = ucontrol->value.enumerated.item[0];
2156
2157         if (val == spec->aamix_mode)
2158                 return 0;
2159         spec->aamix_mode = val;
2160         /* update front path */
2161         update_aamix_paths(codec, val, &spec->out_path[0], &spec->out_mix_path);
2162         /* update HP path */
2163         if (!spec->hp_independent_mode) {
2164                 update_aamix_paths(codec, val, &spec->hp_path,
2165                                    &spec->hp_mix_path);
2166         }
2167         /* update speaker path */
2168         update_aamix_paths(codec, val, &spec->speaker_path,
2169                            &spec->speaker_mix_path);
2170         return 1;
2171 }
2172
2173 static const struct snd_kcontrol_new via_aamix_ctl_enum = {
2174         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2175         .name = "Loopback Mixing",
2176         .info = via_aamix_ctl_info,
2177         .get = via_aamix_ctl_get,
2178         .put = via_aamix_ctl_put,
2179 };
2180
2181 static int via_auto_create_loopback_switch(struct hda_codec *codec)
2182 {
2183         struct via_spec *spec = codec->spec;
2184
2185         if (!spec->aa_mix_nid || !spec->out_mix_path.depth)
2186                 return 0; /* no loopback switching available */
2187         if (!via_clone_control(spec, &via_aamix_ctl_enum))
2188                 return -ENOMEM;
2189         return 0;
2190 }
2191
2192 /* look for ADCs */
2193 static int via_fill_adcs(struct hda_codec *codec)
2194 {
2195         struct via_spec *spec = codec->spec;
2196         hda_nid_t nid = codec->start_nid;
2197         int i;
2198
2199         for (i = 0; i < codec->num_nodes; i++, nid++) {
2200                 unsigned int wcaps = get_wcaps(codec, nid);
2201                 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2202                         continue;
2203                 if (wcaps & AC_WCAP_DIGITAL)
2204                         continue;
2205                 if (!(wcaps & AC_WCAP_CONN_LIST))
2206                         continue;
2207                 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
2208                         return -ENOMEM;
2209                 spec->adc_nids[spec->num_adc_nids++] = nid;
2210         }
2211         return 0;
2212 }
2213
2214 /* input-src control */
2215 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
2216                              struct snd_ctl_elem_info *uinfo)
2217 {
2218         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2219         struct via_spec *spec = codec->spec;
2220
2221         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2222         uinfo->count = 1;
2223         uinfo->value.enumerated.items = spec->num_inputs;
2224         if (uinfo->value.enumerated.item >= spec->num_inputs)
2225                 uinfo->value.enumerated.item = spec->num_inputs - 1;
2226         strcpy(uinfo->value.enumerated.name,
2227                spec->inputs[uinfo->value.enumerated.item].label);
2228         return 0;
2229 }
2230
2231 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
2232                             struct snd_ctl_elem_value *ucontrol)
2233 {
2234         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2235         struct via_spec *spec = codec->spec;
2236         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2237
2238         ucontrol->value.enumerated.item[0] = spec->cur_mux[idx];
2239         return 0;
2240 }
2241
2242 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
2243                             struct snd_ctl_elem_value *ucontrol)
2244 {
2245         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2246         struct via_spec *spec = codec->spec;
2247         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2248         hda_nid_t mux;
2249         int cur;
2250
2251         cur = ucontrol->value.enumerated.item[0];
2252         if (cur < 0 || cur >= spec->num_inputs)
2253                 return -EINVAL;
2254         if (spec->cur_mux[idx] == cur)
2255                 return 0;
2256         spec->cur_mux[idx] = cur;
2257         if (spec->dyn_adc_switch) {
2258                 int adc_idx = spec->inputs[cur].adc_idx;
2259                 mux = spec->mux_nids[adc_idx];
2260                 via_dyn_adc_pcm_resetup(codec, cur);
2261         } else {
2262                 mux = spec->mux_nids[idx];
2263                 if (snd_BUG_ON(!mux))
2264                         return -EINVAL;
2265         }
2266
2267         if (mux) {
2268                 /* switch to D0 beofre change index */
2269                 if (snd_hda_codec_read(codec, mux, 0,
2270                                AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
2271                         snd_hda_codec_write(codec, mux, 0,
2272                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2273                 snd_hda_codec_write(codec, mux, 0,
2274                                     AC_VERB_SET_CONNECT_SEL,
2275                                     spec->inputs[cur].mux_idx);
2276         }
2277
2278         /* update jack power state */
2279         set_widgets_power_state(codec);
2280         return 0;
2281 }
2282
2283 static const struct snd_kcontrol_new via_input_src_ctl = {
2284         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2285         /* The multiple "Capture Source" controls confuse alsamixer
2286          * So call somewhat different..
2287          */
2288         /* .name = "Capture Source", */
2289         .name = "Input Source",
2290         .info = via_mux_enum_info,
2291         .get = via_mux_enum_get,
2292         .put = via_mux_enum_put,
2293 };
2294
2295 static int create_input_src_ctls(struct hda_codec *codec, int count)
2296 {
2297         struct via_spec *spec = codec->spec;
2298         struct snd_kcontrol_new *knew;
2299
2300         if (spec->num_inputs <= 1 || !count)
2301                 return 0; /* no need for single src */
2302
2303         knew = via_clone_control(spec, &via_input_src_ctl);
2304         if (!knew)
2305                 return -ENOMEM;
2306         knew->count = count;
2307         return 0;
2308 }
2309
2310 /* add the powersave loopback-list entry */
2311 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
2312 {
2313         struct hda_amp_list *list;
2314
2315         if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
2316                 return;
2317         list = spec->loopback_list + spec->num_loopbacks;
2318         list->nid = mix;
2319         list->dir = HDA_INPUT;
2320         list->idx = idx;
2321         spec->num_loopbacks++;
2322         spec->loopback.amplist = spec->loopback_list;
2323 }
2324
2325 static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src,
2326                              hda_nid_t dst)
2327 {
2328         return snd_hda_get_conn_index(codec, src, dst, 1) >= 0;
2329 }
2330
2331 /* add the input-route to the given pin */
2332 static bool add_input_route(struct hda_codec *codec, hda_nid_t pin)
2333 {
2334         struct via_spec *spec = codec->spec;
2335         int c, idx;
2336
2337         spec->inputs[spec->num_inputs].adc_idx = -1;
2338         spec->inputs[spec->num_inputs].pin = pin;
2339         for (c = 0; c < spec->num_adc_nids; c++) {
2340                 if (spec->mux_nids[c]) {
2341                         idx = get_connection_index(codec, spec->mux_nids[c],
2342                                                    pin);
2343                         if (idx < 0)
2344                                 continue;
2345                         spec->inputs[spec->num_inputs].mux_idx = idx;
2346                 } else {
2347                         if (!is_reachable_nid(codec, spec->adc_nids[c], pin))
2348                                 continue;
2349                 }
2350                 spec->inputs[spec->num_inputs].adc_idx = c;
2351                 /* Can primary ADC satisfy all inputs? */
2352                 if (!spec->dyn_adc_switch &&
2353                     spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) {
2354                         snd_printd(KERN_INFO
2355                                    "via: dynamic ADC switching enabled\n");
2356                         spec->dyn_adc_switch = 1;
2357                 }
2358                 return true;
2359         }
2360         return false;
2361 }
2362
2363 static int get_mux_nids(struct hda_codec *codec);
2364
2365 /* parse input-routes; fill ADCs, MUXs and input-src entries */
2366 static int parse_analog_inputs(struct hda_codec *codec)
2367 {
2368         struct via_spec *spec = codec->spec;
2369         const struct auto_pin_cfg *cfg = &spec->autocfg;
2370         int i, err;
2371
2372         err = via_fill_adcs(codec);
2373         if (err < 0)
2374                 return err;
2375         err = get_mux_nids(codec);
2376         if (err < 0)
2377                 return err;
2378
2379         /* fill all input-routes */
2380         for (i = 0; i < cfg->num_inputs; i++) {
2381                 if (add_input_route(codec, cfg->inputs[i].pin))
2382                         spec->inputs[spec->num_inputs++].label =
2383                                 hda_get_autocfg_input_label(codec, cfg, i);
2384         }
2385
2386         /* check for internal loopback recording */
2387         if (spec->aa_mix_nid &&
2388             add_input_route(codec, spec->aa_mix_nid))
2389                 spec->inputs[spec->num_inputs++].label = "Stereo Mixer";
2390
2391         return 0;
2392 }
2393
2394 /* create analog-loopback volume/switch controls */
2395 static int create_loopback_ctls(struct hda_codec *codec)
2396 {
2397         struct via_spec *spec = codec->spec;
2398         const struct auto_pin_cfg *cfg = &spec->autocfg;
2399         const char *prev_label = NULL;
2400         int type_idx = 0;
2401         int i, j, err, idx;
2402
2403         if (!spec->aa_mix_nid)
2404                 return 0;
2405
2406         for (i = 0; i < cfg->num_inputs; i++) {
2407                 hda_nid_t pin = cfg->inputs[i].pin;
2408                 const char *label = hda_get_autocfg_input_label(codec, cfg, i);
2409
2410                 if (prev_label && !strcmp(label, prev_label))
2411                         type_idx++;
2412                 else
2413                         type_idx = 0;
2414                 prev_label = label;
2415                 idx = get_connection_index(codec, spec->aa_mix_nid, pin);
2416                 if (idx >= 0) {
2417                         err = via_new_analog_input(spec, label, type_idx,
2418                                                    idx, spec->aa_mix_nid);
2419                         if (err < 0)
2420                                 return err;
2421                         add_loopback_list(spec, spec->aa_mix_nid, idx);
2422                 }
2423
2424                 /* remember the label for smart51 control */
2425                 for (j = 0; j < spec->smart51_nums; j++) {
2426                         if (spec->smart51_pins[j] == pin) {
2427                                 spec->smart51_idxs[j] = idx;
2428                                 spec->smart51_labels[j] = label;
2429                                 break;
2430                         }
2431                 }
2432         }
2433         return 0;
2434 }
2435
2436 /* create mic-boost controls (if present) */
2437 static int create_mic_boost_ctls(struct hda_codec *codec)
2438 {
2439         struct via_spec *spec = codec->spec;
2440         const struct auto_pin_cfg *cfg = &spec->autocfg;
2441         int i, err;
2442
2443         for (i = 0; i < cfg->num_inputs; i++) {
2444                 hda_nid_t pin = cfg->inputs[i].pin;
2445                 unsigned int caps;
2446                 const char *label;
2447                 char name[32];
2448
2449                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2450                         continue;
2451                 caps = query_amp_caps(codec, pin, HDA_INPUT);
2452                 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
2453                         continue;
2454                 label = hda_get_autocfg_input_label(codec, cfg, i);
2455                 snprintf(name, sizeof(name), "%s Boost Volume", label);
2456                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2457                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
2458                 if (err < 0)
2459                         return err;
2460         }
2461         return 0;
2462 }
2463
2464 /* create capture and input-src controls for multiple streams */
2465 static int create_multi_adc_ctls(struct hda_codec *codec)
2466 {
2467         struct via_spec *spec = codec->spec;
2468         int i, err;
2469
2470         /* create capture mixer elements */
2471         for (i = 0; i < spec->num_adc_nids; i++) {
2472                 hda_nid_t adc = spec->adc_nids[i];
2473                 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
2474                                         "Capture Volume", i,
2475                                         HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2476                                                             HDA_INPUT));
2477                 if (err < 0)
2478                         return err;
2479                 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2480                                         "Capture Switch", i,
2481                                         HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2482                                                             HDA_INPUT));
2483                 if (err < 0)
2484                         return err;
2485         }
2486
2487         /* input-source control */
2488         for (i = 0; i < spec->num_adc_nids; i++)
2489                 if (!spec->mux_nids[i])
2490                         break;
2491         err = create_input_src_ctls(codec, i);
2492         if (err < 0)
2493                 return err;
2494         return 0;
2495 }
2496
2497 /* bind capture volume/switch */
2498 static struct snd_kcontrol_new via_bind_cap_vol_ctl =
2499         HDA_BIND_VOL("Capture Volume", 0);
2500 static struct snd_kcontrol_new via_bind_cap_sw_ctl =
2501         HDA_BIND_SW("Capture Switch", 0);
2502
2503 static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret,
2504                          struct hda_ctl_ops *ops)
2505 {
2506         struct hda_bind_ctls *ctl;
2507         int i;
2508
2509         ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL);
2510         if (!ctl)
2511                 return -ENOMEM;
2512         ctl->ops = ops;
2513         for (i = 0; i < spec->num_adc_nids; i++)
2514                 ctl->values[i] =
2515                         HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT);
2516         *ctl_ret = ctl;
2517         return 0;
2518 }
2519
2520 /* create capture and input-src controls for dynamic ADC-switch case */
2521 static int create_dyn_adc_ctls(struct hda_codec *codec)
2522 {
2523         struct via_spec *spec = codec->spec;
2524         struct snd_kcontrol_new *knew;
2525         int err;
2526
2527         /* set up the bind capture ctls */
2528         err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol);
2529         if (err < 0)
2530                 return err;
2531         err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw);
2532         if (err < 0)
2533                 return err;
2534
2535         /* create capture mixer elements */
2536         knew = via_clone_control(spec, &via_bind_cap_vol_ctl);
2537         if (!knew)
2538                 return -ENOMEM;
2539         knew->private_value = (long)spec->bind_cap_vol;
2540
2541         knew = via_clone_control(spec, &via_bind_cap_sw_ctl);
2542         if (!knew)
2543                 return -ENOMEM;
2544         knew->private_value = (long)spec->bind_cap_sw;
2545
2546         /* input-source control */
2547         err = create_input_src_ctls(codec, 1);
2548         if (err < 0)
2549                 return err;
2550         return 0;
2551 }
2552
2553 /* parse and create capture-related stuff */
2554 static int via_auto_create_analog_input_ctls(struct hda_codec *codec)
2555 {
2556         struct via_spec *spec = codec->spec;
2557         int err;
2558
2559         err = parse_analog_inputs(codec);
2560         if (err < 0)
2561                 return err;
2562         if (spec->dyn_adc_switch)
2563                 err = create_dyn_adc_ctls(codec);
2564         else
2565                 err = create_multi_adc_ctls(codec);
2566         if (err < 0)
2567                 return err;
2568         err = create_loopback_ctls(codec);
2569         if (err < 0)
2570                 return err;
2571         err = create_mic_boost_ctls(codec);
2572         if (err < 0)
2573                 return err;
2574         return 0;
2575 }
2576
2577 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
2578 {
2579         unsigned int def_conf;
2580         unsigned char seqassoc;
2581
2582         def_conf = snd_hda_codec_get_pincfg(codec, nid);
2583         seqassoc = (unsigned char) get_defcfg_association(def_conf);
2584         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2585         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
2586             && (seqassoc == 0xf0 || seqassoc == 0xff)) {
2587                 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2588                 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2589         }
2590
2591         return;
2592 }
2593
2594 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2595                                      struct snd_ctl_elem_value *ucontrol)
2596 {
2597         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2598         struct via_spec *spec = codec->spec;
2599
2600         if (spec->codec_type != VT1708)
2601                 return 0;
2602         spec->vt1708_jack_detect =
2603                 !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
2604         ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2605         return 0;
2606 }
2607
2608 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2609                                      struct snd_ctl_elem_value *ucontrol)
2610 {
2611         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2612         struct via_spec *spec = codec->spec;
2613         int change;
2614
2615         if (spec->codec_type != VT1708)
2616                 return 0;
2617         spec->vt1708_jack_detect = ucontrol->value.integer.value[0];
2618         change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
2619                 == !spec->vt1708_jack_detect;
2620         if (spec->vt1708_jack_detect) {
2621                 mute_aa_path(codec, 1);
2622                 notify_aa_path_ctls(codec);
2623         }
2624         return change;
2625 }
2626
2627 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
2628         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2629         .name = "Jack Detect",
2630         .count = 1,
2631         .info = snd_ctl_boolean_mono_info,
2632         .get = vt1708_jack_detect_get,
2633         .put = vt1708_jack_detect_put,
2634 };
2635
2636 static void fill_dig_outs(struct hda_codec *codec);
2637 static void fill_dig_in(struct hda_codec *codec);
2638
2639 static int via_parse_auto_config(struct hda_codec *codec)
2640 {
2641         struct via_spec *spec = codec->spec;
2642         int err;
2643
2644         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2645         if (err < 0)
2646                 return err;
2647         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2648                 return -EINVAL;
2649
2650         err = via_auto_create_multi_out_ctls(codec);
2651         if (err < 0)
2652                 return err;
2653         err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2654         if (err < 0)
2655                 return err;
2656         err = via_auto_create_speaker_ctls(codec);
2657         if (err < 0)
2658                 return err;
2659         err = via_auto_create_loopback_switch(codec);
2660         if (err < 0)
2661                 return err;
2662         err = via_auto_create_analog_input_ctls(codec);
2663         if (err < 0)
2664                 return err;
2665
2666         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2667
2668         fill_dig_outs(codec);
2669         fill_dig_in(codec);
2670
2671         if (spec->kctls.list)
2672                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2673
2674
2675         if (spec->hp_dac_nid && spec->hp_mix_path.depth) {
2676                 err = via_hp_build(codec);
2677                 if (err < 0)
2678                         return err;
2679         }
2680
2681         err = via_smart51_build(codec);
2682         if (err < 0)
2683                 return err;
2684
2685         /* assign slave outs */
2686         if (spec->slave_dig_outs[0])
2687                 codec->slave_dig_outs = spec->slave_dig_outs;
2688
2689         return 1;
2690 }
2691
2692 static void via_auto_init_dig_outs(struct hda_codec *codec)
2693 {
2694         struct via_spec *spec = codec->spec;
2695         if (spec->multiout.dig_out_nid)
2696                 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
2697         if (spec->slave_dig_outs[0])
2698                 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
2699 }
2700
2701 static void via_auto_init_dig_in(struct hda_codec *codec)
2702 {
2703         struct via_spec *spec = codec->spec;
2704         if (!spec->dig_in_nid)
2705                 return;
2706         snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2707                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2708 }
2709
2710 /* initialize the unsolicited events */
2711 static void via_auto_init_unsol_event(struct hda_codec *codec)
2712 {
2713         struct via_spec *spec = codec->spec;
2714         struct auto_pin_cfg *cfg = &spec->autocfg;
2715         unsigned int ev;
2716         int i;
2717
2718         if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
2719                 snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
2720                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2721                                 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);
2722
2723         if (cfg->speaker_pins[0])
2724                 ev = VIA_LINE_EVENT;
2725         else
2726                 ev = 0;
2727         for (i = 0; i < cfg->line_outs; i++) {
2728                 if (cfg->line_out_pins[i] &&
2729                     is_jack_detectable(codec, cfg->line_out_pins[i]))
2730                         snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
2731                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2732                                 AC_USRSP_EN | ev | VIA_JACK_EVENT);
2733         }
2734
2735         for (i = 0; i < cfg->num_inputs; i++) {
2736                 if (is_jack_detectable(codec, cfg->inputs[i].pin))
2737                         snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
2738                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2739                                 AC_USRSP_EN | VIA_JACK_EVENT);
2740         }
2741 }
2742
2743 static int via_init(struct hda_codec *codec)
2744 {
2745         struct via_spec *spec = codec->spec;
2746         int i;
2747
2748         for (i = 0; i < spec->num_iverbs; i++)
2749                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2750
2751         via_auto_init_multi_out(codec);
2752         via_auto_init_hp_out(codec);
2753         via_auto_init_speaker_out(codec);
2754         via_auto_init_analog_input(codec);
2755         via_auto_init_dig_outs(codec);
2756         via_auto_init_dig_in(codec);
2757
2758         via_auto_init_unsol_event(codec);
2759
2760         via_hp_automute(codec);
2761
2762         return 0;
2763 }
2764
2765 static void vt1708_update_hp_jack_state(struct work_struct *work)
2766 {
2767         struct via_spec *spec = container_of(work, struct via_spec,
2768                                              vt1708_hp_work.work);
2769         if (spec->codec_type != VT1708)
2770                 return;
2771         /* if jack state toggled */
2772         if (spec->vt1708_hp_present
2773             != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2774                 spec->vt1708_hp_present ^= 1;
2775                 via_hp_automute(spec->codec);
2776         }
2777         vt1708_start_hp_work(spec);
2778 }
2779
2780 static int get_mux_nids(struct hda_codec *codec)
2781 {
2782         struct via_spec *spec = codec->spec;
2783         hda_nid_t nid, conn[8];
2784         unsigned int type;
2785         int i, n;
2786
2787         for (i = 0; i < spec->num_adc_nids; i++) {
2788                 nid = spec->adc_nids[i];
2789                 while (nid) {
2790                         type = get_wcaps_type(get_wcaps(codec, nid));
2791                         if (type == AC_WID_PIN)
2792                                 break;
2793                         n = snd_hda_get_connections(codec, nid, conn,
2794                                                     ARRAY_SIZE(conn));
2795                         if (n <= 0)
2796                                 break;
2797                         if (n > 1) {
2798                                 spec->mux_nids[i] = nid;
2799                                 break;
2800                         }
2801                         nid = conn[0];
2802                 }
2803         }
2804         return 0;
2805 }
2806
2807 static int patch_vt1708(struct hda_codec *codec)
2808 {
2809         struct via_spec *spec;
2810         int err;
2811
2812         /* create a codec specific record */
2813         spec = via_new_spec(codec);
2814         if (spec == NULL)
2815                 return -ENOMEM;
2816
2817         spec->aa_mix_nid = 0x17;
2818
2819         /* Add HP and CD pin config connect bit re-config action */
2820         vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2821         vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2822
2823         /* automatic parse from the BIOS config */
2824         err = via_parse_auto_config(codec);
2825         if (err < 0) {
2826                 via_free(codec);
2827                 return err;
2828         }
2829
2830         /* add jack detect on/off control */
2831         if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
2832                 return -ENOMEM;
2833
2834         /* disable 32bit format on VT1708 */
2835         if (codec->vendor_id == 0x11061708)
2836                 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2837
2838         spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
2839
2840         codec->patch_ops = via_patch_ops;
2841
2842         INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2843         return 0;
2844 }
2845
2846 static int patch_vt1709(struct hda_codec *codec)
2847 {
2848         struct via_spec *spec;
2849         int err;
2850
2851         /* create a codec specific record */
2852         spec = via_new_spec(codec);
2853         if (spec == NULL)
2854                 return -ENOMEM;
2855
2856         spec->aa_mix_nid = 0x18;
2857
2858         err = via_parse_auto_config(codec);
2859         if (err < 0) {
2860                 via_free(codec);
2861                 return err;
2862         }
2863
2864         codec->patch_ops = via_patch_ops;
2865
2866         return 0;
2867 }
2868
2869 static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
2870 {
2871         struct via_spec *spec = codec->spec;
2872         int imux_is_smixer;
2873         unsigned int parm;
2874         int is_8ch = 0;
2875         if ((spec->codec_type != VT1708B_4CH) &&
2876             (codec->vendor_id != 0x11064397))
2877                 is_8ch = 1;
2878
2879         /* SW0 (17h) = stereo mixer */
2880         imux_is_smixer =
2881         (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
2882          == ((spec->codec_type == VT1708S) ? 5 : 0));
2883         /* inputs */
2884         /* PW 1/2/5 (1ah/1bh/1eh) */
2885         parm = AC_PWRST_D3;
2886         set_pin_power_state(codec, 0x1a, &parm);
2887         set_pin_power_state(codec, 0x1b, &parm);
2888         set_pin_power_state(codec, 0x1e, &parm);
2889         if (imux_is_smixer)
2890                 parm = AC_PWRST_D0;
2891         /* SW0 (17h), AIW 0/1 (13h/14h) */
2892         snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2893         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2894         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2895
2896         /* outputs */
2897         /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2898         parm = AC_PWRST_D3;
2899         set_pin_power_state(codec, 0x19, &parm);
2900         if (spec->smart51_enabled)
2901                 set_pin_power_state(codec, 0x1b, &parm);
2902         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2903         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2904
2905         /* PW6 (22h), SW2 (26h), AOW2 (24h) */
2906         if (is_8ch) {
2907                 parm = AC_PWRST_D3;
2908                 set_pin_power_state(codec, 0x22, &parm);
2909                 if (spec->smart51_enabled)
2910                         set_pin_power_state(codec, 0x1a, &parm);
2911                 snd_hda_codec_write(codec, 0x26, 0,
2912                                     AC_VERB_SET_POWER_STATE, parm);
2913                 snd_hda_codec_write(codec, 0x24, 0,
2914                                     AC_VERB_SET_POWER_STATE, parm);
2915         } else if (codec->vendor_id == 0x11064397) {
2916                 /* PW7(23h), SW2(27h), AOW2(25h) */
2917                 parm = AC_PWRST_D3;
2918                 set_pin_power_state(codec, 0x23, &parm);
2919                 if (spec->smart51_enabled)
2920                         set_pin_power_state(codec, 0x1a, &parm);
2921                 snd_hda_codec_write(codec, 0x27, 0,
2922                                     AC_VERB_SET_POWER_STATE, parm);
2923                 snd_hda_codec_write(codec, 0x25, 0,
2924                                     AC_VERB_SET_POWER_STATE, parm);
2925         }
2926
2927         /* PW 3/4/7 (1ch/1dh/23h) */
2928         parm = AC_PWRST_D3;
2929         /* force to D0 for internal Speaker */
2930         set_pin_power_state(codec, 0x1c, &parm);
2931         set_pin_power_state(codec, 0x1d, &parm);
2932         if (is_8ch)
2933                 set_pin_power_state(codec, 0x23, &parm);
2934
2935         /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
2936         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2937                             imux_is_smixer ? AC_PWRST_D0 : parm);
2938         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2939         if (is_8ch) {
2940                 snd_hda_codec_write(codec, 0x25, 0,
2941                                     AC_VERB_SET_POWER_STATE, parm);
2942                 snd_hda_codec_write(codec, 0x27, 0,
2943                                     AC_VERB_SET_POWER_STATE, parm);
2944         } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
2945                 snd_hda_codec_write(codec, 0x25, 0,
2946                                     AC_VERB_SET_POWER_STATE, parm);
2947 }
2948
2949 static int patch_vt1708S(struct hda_codec *codec);
2950 static int patch_vt1708B(struct hda_codec *codec)
2951 {
2952         struct via_spec *spec;
2953         int err;
2954
2955         if (get_codec_type(codec) == VT1708BCE)
2956                 return patch_vt1708S(codec);
2957
2958         /* create a codec specific record */
2959         spec = via_new_spec(codec);
2960         if (spec == NULL)
2961                 return -ENOMEM;
2962
2963         spec->aa_mix_nid = 0x16;
2964
2965         /* automatic parse from the BIOS config */
2966         err = via_parse_auto_config(codec);
2967         if (err < 0) {
2968                 via_free(codec);
2969                 return err;
2970         }
2971
2972         codec->patch_ops = via_patch_ops;
2973
2974         spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;
2975
2976         return 0;
2977 }
2978
2979 /* Patch for VT1708S */
2980 static const struct hda_verb vt1708S_init_verbs[] = {
2981         /* Enable Mic Boost Volume backdoor */
2982         {0x1, 0xf98, 0x1},
2983         /* don't bybass mixer */
2984         {0x1, 0xf88, 0xc0},
2985         { }
2986 };
2987
2988 /* fill out digital output widgets; one for master and one for slave outputs */
2989 static void fill_dig_outs(struct hda_codec *codec)
2990 {
2991         struct via_spec *spec = codec->spec;
2992         int i;
2993
2994         for (i = 0; i < spec->autocfg.dig_outs; i++) {
2995                 hda_nid_t nid;
2996                 int conn;
2997
2998                 nid = spec->autocfg.dig_out_pins[i];
2999                 if (!nid)
3000                         continue;
3001                 conn = snd_hda_get_connections(codec, nid, &nid, 1);
3002                 if (conn < 1)
3003                         continue;
3004                 if (!spec->multiout.dig_out_nid)
3005                         spec->multiout.dig_out_nid = nid;
3006                 else {
3007                         spec->slave_dig_outs[0] = nid;
3008                         break; /* at most two dig outs */
3009                 }
3010         }
3011 }
3012
3013 static void fill_dig_in(struct hda_codec *codec)
3014 {
3015         struct via_spec *spec = codec->spec;
3016         hda_nid_t dig_nid;
3017         int i, err;
3018
3019         if (!spec->autocfg.dig_in_pin)
3020                 return;
3021
3022         dig_nid = codec->start_nid;
3023         for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3024                 unsigned int wcaps = get_wcaps(codec, dig_nid);
3025                 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3026                         continue;
3027                 if (!(wcaps & AC_WCAP_DIGITAL))
3028                         continue;
3029                 if (!(wcaps & AC_WCAP_CONN_LIST))
3030                         continue;
3031                 err = get_connection_index(codec, dig_nid,
3032                                            spec->autocfg.dig_in_pin);
3033                 if (err >= 0) {
3034                         spec->dig_in_nid = dig_nid;
3035                         break;
3036                 }
3037         }
3038 }
3039
3040 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
3041                                int offset, int num_steps, int step_size)
3042 {
3043         snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
3044                                   (offset << AC_AMPCAP_OFFSET_SHIFT) |
3045                                   (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
3046                                   (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
3047                                   (0 << AC_AMPCAP_MUTE_SHIFT));
3048 }
3049
3050 static int patch_vt1708S(struct hda_codec *codec)
3051 {
3052         struct via_spec *spec;
3053         int err;
3054
3055         /* create a codec specific record */
3056         spec = via_new_spec(codec);
3057         if (spec == NULL)
3058                 return -ENOMEM;
3059
3060         spec->aa_mix_nid = 0x16;
3061         override_mic_boost(codec, 0x1a, 0, 3, 40);
3062         override_mic_boost(codec, 0x1e, 0, 3, 40);
3063
3064         /* automatic parse from the BIOS config */
3065         err = via_parse_auto_config(codec);
3066         if (err < 0) {
3067                 via_free(codec);
3068                 return err;
3069         }
3070
3071         spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
3072
3073         codec->patch_ops = via_patch_ops;
3074
3075         /* correct names for VT1708BCE */
3076         if (get_codec_type(codec) == VT1708BCE) {
3077                 kfree(codec->chip_name);
3078                 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
3079                 snprintf(codec->bus->card->mixername,
3080                          sizeof(codec->bus->card->mixername),
3081                          "%s %s", codec->vendor_name, codec->chip_name);
3082         }
3083         /* correct names for VT1705 */
3084         if (codec->vendor_id == 0x11064397)     {
3085                 kfree(codec->chip_name);
3086                 codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
3087                 snprintf(codec->bus->card->mixername,
3088                          sizeof(codec->bus->card->mixername),
3089                          "%s %s", codec->vendor_name, codec->chip_name);
3090         }
3091         spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;
3092         return 0;
3093 }
3094
3095 /* Patch for VT1702 */
3096
3097 static const struct hda_verb vt1702_init_verbs[] = {
3098         /* mixer enable */
3099         {0x1, 0xF88, 0x3},
3100         /* GPIO 0~2 */
3101         {0x1, 0xF82, 0x3F},
3102         { }
3103 };
3104
3105 static void set_widgets_power_state_vt1702(struct hda_codec *codec)
3106 {
3107         int imux_is_smixer =
3108         snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3109         unsigned int parm;
3110         /* inputs */
3111         /* PW 1/2/5 (14h/15h/18h) */
3112         parm = AC_PWRST_D3;
3113         set_pin_power_state(codec, 0x14, &parm);
3114         set_pin_power_state(codec, 0x15, &parm);
3115         set_pin_power_state(codec, 0x18, &parm);
3116         if (imux_is_smixer)
3117                 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
3118         /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
3119         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3120         snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm);
3121         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3122         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm);
3123
3124         /* outputs */
3125         /* PW 3/4 (16h/17h) */
3126         parm = AC_PWRST_D3;
3127         set_pin_power_state(codec, 0x17, &parm);
3128         set_pin_power_state(codec, 0x16, &parm);
3129         /* MW0 (1ah), AOW 0/1 (10h/1dh) */
3130         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
3131                             imux_is_smixer ? AC_PWRST_D0 : parm);
3132         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3133         snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3134 }
3135
3136 static int patch_vt1702(struct hda_codec *codec)
3137 {
3138         struct via_spec *spec;
3139         int err;
3140
3141         /* create a codec specific record */
3142         spec = via_new_spec(codec);
3143         if (spec == NULL)
3144                 return -ENOMEM;
3145
3146         spec->aa_mix_nid = 0x1a;
3147
3148         /* limit AA path volume to 0 dB */
3149         snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
3150                                   (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
3151                                   (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3152                                   (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3153                                   (1 << AC_AMPCAP_MUTE_SHIFT));
3154
3155         /* automatic parse from the BIOS config */
3156         err = via_parse_auto_config(codec);
3157         if (err < 0) {
3158                 via_free(codec);
3159                 return err;
3160         }
3161
3162         spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
3163
3164         codec->patch_ops = via_patch_ops;
3165
3166         spec->set_widgets_power_state =  set_widgets_power_state_vt1702;
3167         return 0;
3168 }
3169
3170 /* Patch for VT1718S */
3171
3172 static const struct hda_verb vt1718S_init_verbs[] = {
3173         /* Enable MW0 adjust Gain 5 */
3174         {0x1, 0xfb2, 0x10},
3175         /* Enable Boost Volume backdoor */
3176         {0x1, 0xf88, 0x8},
3177
3178         { }
3179 };
3180
3181 static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
3182 {
3183         struct via_spec *spec = codec->spec;
3184         int imux_is_smixer;
3185         unsigned int parm;
3186         /* MUX6 (1eh) = stereo mixer */
3187         imux_is_smixer =
3188         snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
3189         /* inputs */
3190         /* PW 5/6/7 (29h/2ah/2bh) */
3191         parm = AC_PWRST_D3;
3192         set_pin_power_state(codec, 0x29, &parm);
3193         set_pin_power_state(codec, 0x2a, &parm);
3194         set_pin_power_state(codec, 0x2b, &parm);
3195         if (imux_is_smixer)
3196                 parm = AC_PWRST_D0;
3197         /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
3198         snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3199         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3200         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3201         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3202
3203         /* outputs */
3204         /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
3205         parm = AC_PWRST_D3;
3206         set_pin_power_state(codec, 0x27, &parm);
3207         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm);
3208         snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm);
3209
3210         /* PW2 (26h), AOW2 (ah) */
3211         parm = AC_PWRST_D3;
3212         set_pin_power_state(codec, 0x26, &parm);
3213         if (spec->smart51_enabled)
3214                 set_pin_power_state(codec, 0x2b, &parm);
3215         snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm);
3216
3217         /* PW0 (24h), AOW0 (8h) */
3218         parm = AC_PWRST_D3;
3219         set_pin_power_state(codec, 0x24, &parm);
3220         if (!spec->hp_independent_mode) /* check for redirected HP */
3221                 set_pin_power_state(codec, 0x28, &parm);
3222         snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3223         /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
3224         snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
3225                             imux_is_smixer ? AC_PWRST_D0 : parm);
3226
3227         /* PW1 (25h), AOW1 (9h) */
3228         parm = AC_PWRST_D3;
3229         set_pin_power_state(codec, 0x25, &parm);
3230         if (spec->smart51_enabled)
3231                 set_pin_power_state(codec, 0x2a, &parm);
3232         snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm);
3233
3234         if (spec->hp_independent_mode) {
3235                 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
3236                 parm = AC_PWRST_D3;
3237                 set_pin_power_state(codec, 0x28, &parm);
3238                 snd_hda_codec_write(codec, 0x1b, 0,
3239                                     AC_VERB_SET_POWER_STATE, parm);
3240                 snd_hda_codec_write(codec, 0x34, 0,
3241                                     AC_VERB_SET_POWER_STATE, parm);
3242                 snd_hda_codec_write(codec, 0xc, 0,
3243                                     AC_VERB_SET_POWER_STATE, parm);
3244         }
3245 }
3246
3247 /* Add a connection to the primary DAC from AA-mixer for some codecs
3248  * This isn't listed from the raw info, but the chip has a secret connection.
3249  */
3250 static int add_secret_dac_path(struct hda_codec *codec)
3251 {
3252         struct via_spec *spec = codec->spec;
3253         int i, nums;
3254         hda_nid_t conn[8];
3255         hda_nid_t nid;
3256
3257         if (!spec->aa_mix_nid)
3258                 return 0;
3259         nums = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
3260                                        ARRAY_SIZE(conn) - 1);
3261         for (i = 0; i < nums; i++) {
3262                 if (get_wcaps_type(get_wcaps(codec, conn[i])) == AC_WID_AUD_OUT)
3263                         return 0;
3264         }
3265
3266         /* find the primary DAC and add to the connection list */
3267         nid = codec->start_nid;
3268         for (i = 0; i < codec->num_nodes; i++, nid++) {
3269                 unsigned int caps = get_wcaps(codec, nid);
3270                 if (get_wcaps_type(caps) == AC_WID_AUD_OUT &&
3271                     !(caps & AC_WCAP_DIGITAL)) {
3272                         conn[nums++] = nid;
3273                         return snd_hda_override_conn_list(codec,
3274                                                           spec->aa_mix_nid,
3275                                                           nums, conn);
3276                 }
3277         }
3278         return 0;
3279 }
3280
3281
3282 static int patch_vt1718S(struct hda_codec *codec)
3283 {
3284         struct via_spec *spec;
3285         int err;
3286
3287         /* create a codec specific record */
3288         spec = via_new_spec(codec);
3289         if (spec == NULL)
3290                 return -ENOMEM;
3291
3292         spec->aa_mix_nid = 0x21;
3293         override_mic_boost(codec, 0x2b, 0, 3, 40);
3294         override_mic_boost(codec, 0x29, 0, 3, 40);
3295         add_secret_dac_path(codec);
3296
3297         /* automatic parse from the BIOS config */
3298         err = via_parse_auto_config(codec);
3299         if (err < 0) {
3300                 via_free(codec);
3301                 return err;
3302         }
3303
3304         spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
3305
3306         codec->patch_ops = via_patch_ops;
3307
3308         spec->set_widgets_power_state =  set_widgets_power_state_vt1718S;
3309
3310         return 0;
3311 }
3312
3313 /* Patch for VT1716S */
3314
3315 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
3316                             struct snd_ctl_elem_info *uinfo)
3317 {
3318         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3319         uinfo->count = 1;
3320         uinfo->value.integer.min = 0;
3321         uinfo->value.integer.max = 1;
3322         return 0;
3323 }
3324
3325 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
3326                            struct snd_ctl_elem_value *ucontrol)
3327 {
3328         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3329         int index = 0;
3330
3331         index = snd_hda_codec_read(codec, 0x26, 0,
3332                                                AC_VERB_GET_CONNECT_SEL, 0);
3333         if (index != -1)
3334                 *ucontrol->value.integer.value = index;
3335
3336         return 0;
3337 }
3338
3339 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
3340                            struct snd_ctl_elem_value *ucontrol)
3341 {
3342         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3343         struct via_spec *spec = codec->spec;
3344         int index = *ucontrol->value.integer.value;
3345
3346         snd_hda_codec_write(codec, 0x26, 0,
3347                                                AC_VERB_SET_CONNECT_SEL, index);
3348         spec->dmic_enabled = index;
3349         set_widgets_power_state(codec);
3350         return 1;
3351 }
3352
3353 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
3354         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
3355         {
3356          .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3357          .name = "Digital Mic Capture Switch",
3358          .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
3359          .count = 1,
3360          .info = vt1716s_dmic_info,
3361          .get = vt1716s_dmic_get,
3362          .put = vt1716s_dmic_put,
3363          },
3364         {}                      /* end */
3365 };
3366
3367
3368 /* mono-out mixer elements */
3369 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
3370         HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
3371         { } /* end */
3372 };
3373
3374 static const struct hda_verb vt1716S_init_verbs[] = {
3375         /* Enable Boost Volume backdoor */
3376         {0x1, 0xf8a, 0x80},
3377         /* don't bybass mixer */
3378         {0x1, 0xf88, 0xc0},
3379         /* Enable mono output */
3380         {0x1, 0xf90, 0x08},
3381         { }
3382 };
3383
3384 static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
3385 {
3386         struct via_spec *spec = codec->spec;
3387         int imux_is_smixer;
3388         unsigned int parm;
3389         unsigned int mono_out, present;
3390         /* SW0 (17h) = stereo mixer */
3391         imux_is_smixer =
3392         (snd_hda_codec_read(codec, 0x17, 0,
3393                             AC_VERB_GET_CONNECT_SEL, 0x00) ==  5);
3394         /* inputs */
3395         /* PW 1/2/5 (1ah/1bh/1eh) */
3396         parm = AC_PWRST_D3;
3397         set_pin_power_state(codec, 0x1a, &parm);
3398         set_pin_power_state(codec, 0x1b, &parm);
3399         set_pin_power_state(codec, 0x1e, &parm);
3400         if (imux_is_smixer)
3401                 parm = AC_PWRST_D0;
3402         /* SW0 (17h), AIW0(13h) */
3403         snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
3404         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3405
3406         parm = AC_PWRST_D3;
3407         set_pin_power_state(codec, 0x1e, &parm);
3408         /* PW11 (22h) */
3409         if (spec->dmic_enabled)
3410                 set_pin_power_state(codec, 0x22, &parm);
3411         else
3412                 snd_hda_codec_write(codec, 0x22, 0,
3413                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3414
3415         /* SW2(26h), AIW1(14h) */
3416         snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm);
3417         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
3418
3419         /* outputs */
3420         /* PW0 (19h), SW1 (18h), AOW1 (11h) */
3421         parm = AC_PWRST_D3;
3422         set_pin_power_state(codec, 0x19, &parm);
3423         /* Smart 5.1 PW2(1bh) */
3424         if (spec->smart51_enabled)
3425                 set_pin_power_state(codec, 0x1b, &parm);
3426         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3427         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3428
3429         /* PW7 (23h), SW3 (27h), AOW3 (25h) */
3430         parm = AC_PWRST_D3;
3431         set_pin_power_state(codec, 0x23, &parm);
3432         /* Smart 5.1 PW1(1ah) */
3433         if (spec->smart51_enabled)
3434                 set_pin_power_state(codec, 0x1a, &parm);
3435         snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm);
3436
3437         /* Smart 5.1 PW5(1eh) */
3438         if (spec->smart51_enabled)
3439                 set_pin_power_state(codec, 0x1e, &parm);
3440         snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm);
3441
3442         /* Mono out */
3443         /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
3444         present = snd_hda_jack_detect(codec, 0x1c);
3445
3446         if (present)
3447                 mono_out = 0;
3448         else {
3449                 present = snd_hda_jack_detect(codec, 0x1d);
3450                 if (!spec->hp_independent_mode && present)
3451                         mono_out = 0;
3452                 else
3453                         mono_out = 1;
3454         }
3455         parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
3456         snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm);
3457         snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm);
3458         snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm);
3459
3460         /* PW 3/4 (1ch/1dh) */
3461         parm = AC_PWRST_D3;
3462         set_pin_power_state(codec, 0x1c, &parm);
3463         set_pin_power_state(codec, 0x1d, &parm);
3464         /* HP Independent Mode, power on AOW3 */
3465         if (spec->hp_independent_mode)
3466                 snd_hda_codec_write(codec, 0x25, 0,
3467                                     AC_VERB_SET_POWER_STATE, parm);
3468
3469         /* force to D0 for internal Speaker */
3470         /* MW0 (16h), AOW0 (10h) */
3471         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
3472                             imux_is_smixer ? AC_PWRST_D0 : parm);
3473         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
3474                             mono_out ? AC_PWRST_D0 : parm);
3475 }
3476
3477 static int patch_vt1716S(struct hda_codec *codec)
3478 {
3479         struct via_spec *spec;
3480         int err;
3481
3482         /* create a codec specific record */
3483         spec = via_new_spec(codec);
3484         if (spec == NULL)
3485                 return -ENOMEM;
3486
3487         spec->aa_mix_nid = 0x16;
3488         override_mic_boost(codec, 0x1a, 0, 3, 40);
3489         override_mic_boost(codec, 0x1e, 0, 3, 40);
3490
3491         /* automatic parse from the BIOS config */
3492         err = via_parse_auto_config(codec);
3493         if (err < 0) {
3494                 via_free(codec);
3495                 return err;
3496         }
3497
3498         spec->init_verbs[spec->num_iverbs++]  = vt1716S_init_verbs;
3499
3500         spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
3501         spec->num_mixers++;
3502
3503         spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
3504
3505         codec->patch_ops = via_patch_ops;
3506
3507         spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
3508         return 0;
3509 }
3510
3511 /* for vt2002P */
3512
3513 static const struct hda_verb vt2002P_init_verbs[] = {
3514         /* Class-D speaker related verbs */
3515         {0x1, 0xfe0, 0x4},
3516         {0x1, 0xfe9, 0x80},
3517         {0x1, 0xfe2, 0x22},
3518         /* Enable Boost Volume backdoor */
3519         {0x1, 0xfb9, 0x24},
3520         /* Enable AOW0 to MW9 */
3521         {0x1, 0xfb8, 0x88},
3522         { }
3523 };
3524
3525 static const struct hda_verb vt1802_init_verbs[] = {
3526         /* Enable Boost Volume backdoor */
3527         {0x1, 0xfb9, 0x24},
3528         /* Enable AOW0 to MW9 */
3529         {0x1, 0xfb8, 0x88},
3530         { }
3531 };
3532
3533 static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
3534 {
3535         struct via_spec *spec = codec->spec;
3536         int imux_is_smixer;
3537         unsigned int parm;
3538         unsigned int present;
3539         /* MUX9 (1eh) = stereo mixer */
3540         imux_is_smixer =
3541         snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3542         /* inputs */
3543         /* PW 5/6/7 (29h/2ah/2bh) */
3544         parm = AC_PWRST_D3;
3545         set_pin_power_state(codec, 0x29, &parm);
3546         set_pin_power_state(codec, 0x2a, &parm);
3547         set_pin_power_state(codec, 0x2b, &parm);
3548         parm = AC_PWRST_D0;
3549         /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
3550         snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3551         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3552         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3553         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3554
3555         /* outputs */
3556         /* AOW0 (8h)*/
3557         snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3558
3559         if (spec->codec_type == VT1802) {
3560                 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3561                 parm = AC_PWRST_D3;
3562                 set_pin_power_state(codec, 0x28, &parm);
3563                 snd_hda_codec_write(codec, 0x18, 0,
3564                                     AC_VERB_SET_POWER_STATE, parm);
3565                 snd_hda_codec_write(codec, 0x38, 0,
3566                                     AC_VERB_SET_POWER_STATE, parm);
3567         } else {
3568                 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
3569                 parm = AC_PWRST_D3;
3570                 set_pin_power_state(codec, 0x26, &parm);
3571                 snd_hda_codec_write(codec, 0x1c, 0,
3572                                     AC_VERB_SET_POWER_STATE, parm);
3573                 snd_hda_codec_write(codec, 0x37, 0,
3574                                     AC_VERB_SET_POWER_STATE, parm);
3575         }
3576
3577         if (spec->codec_type == VT1802) {
3578                 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3579                 parm = AC_PWRST_D3;
3580                 set_pin_power_state(codec, 0x25, &parm);
3581                 snd_hda_codec_write(codec, 0x15, 0,
3582                                     AC_VERB_SET_POWER_STATE, parm);
3583                 snd_hda_codec_write(codec, 0x35, 0,
3584                                     AC_VERB_SET_POWER_STATE, parm);
3585         } else {
3586                 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
3587                 parm = AC_PWRST_D3;
3588                 set_pin_power_state(codec, 0x25, &parm);
3589                 snd_hda_codec_write(codec, 0x19, 0,
3590                                     AC_VERB_SET_POWER_STATE, parm);
3591                 snd_hda_codec_write(codec, 0x35, 0,
3592                                     AC_VERB_SET_POWER_STATE, parm);
3593         }
3594
3595         if (spec->hp_independent_mode)
3596                 snd_hda_codec_write(codec, 0x9, 0,
3597                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3598
3599         /* Class-D */
3600         /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
3601         present = snd_hda_jack_detect(codec, 0x25);
3602
3603         parm = AC_PWRST_D3;
3604         set_pin_power_state(codec, 0x24, &parm);
3605         parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3606         if (spec->codec_type == VT1802)
3607                 snd_hda_codec_write(codec, 0x14, 0,
3608                                     AC_VERB_SET_POWER_STATE, parm);
3609         else
3610                 snd_hda_codec_write(codec, 0x18, 0,
3611                                     AC_VERB_SET_POWER_STATE, parm);
3612         snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm);
3613
3614         /* Mono Out */
3615         present = snd_hda_jack_detect(codec, 0x26);
3616
3617         parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3618         if (spec->codec_type == VT1802) {
3619                 /* PW15 (33h), MW8(1ch), MUX8(3ch) */
3620                 snd_hda_codec_write(codec, 0x33, 0,
3621                                     AC_VERB_SET_POWER_STATE, parm);
3622                 snd_hda_codec_write(codec, 0x1c, 0,
3623                                     AC_VERB_SET_POWER_STATE, parm);
3624                 snd_hda_codec_write(codec, 0x3c, 0,
3625                                     AC_VERB_SET_POWER_STATE, parm);
3626         } else {
3627                 /* PW15 (31h), MW8(17h), MUX8(3bh) */
3628                 snd_hda_codec_write(codec, 0x31, 0,
3629                                     AC_VERB_SET_POWER_STATE, parm);
3630                 snd_hda_codec_write(codec, 0x17, 0,
3631                                     AC_VERB_SET_POWER_STATE, parm);
3632                 snd_hda_codec_write(codec, 0x3b, 0,
3633                                     AC_VERB_SET_POWER_STATE, parm);
3634         }
3635         /* MW9 (21h) */
3636         if (imux_is_smixer || !is_aa_path_mute(codec))
3637                 snd_hda_codec_write(codec, 0x21, 0,
3638                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3639         else
3640                 snd_hda_codec_write(codec, 0x21, 0,
3641                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3642 }
3643
3644 /* patch for vt2002P */
3645 static int patch_vt2002P(struct hda_codec *codec)
3646 {
3647         struct via_spec *spec;
3648         int err;
3649
3650         /* create a codec specific record */
3651         spec = via_new_spec(codec);
3652         if (spec == NULL)
3653                 return -ENOMEM;
3654
3655         spec->aa_mix_nid = 0x21;
3656         override_mic_boost(codec, 0x2b, 0, 3, 40);
3657         override_mic_boost(codec, 0x29, 0, 3, 40);
3658         add_secret_dac_path(codec);
3659
3660         /* automatic parse from the BIOS config */
3661         err = via_parse_auto_config(codec);
3662         if (err < 0) {
3663                 via_free(codec);
3664                 return err;
3665         }
3666
3667         if (spec->codec_type == VT1802)
3668                 spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
3669         else
3670                 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
3671
3672         codec->patch_ops = via_patch_ops;
3673
3674         spec->set_widgets_power_state =  set_widgets_power_state_vt2002P;
3675         return 0;
3676 }
3677
3678 /* for vt1812 */
3679
3680 static const struct hda_verb vt1812_init_verbs[] = {
3681         /* Enable Boost Volume backdoor */
3682         {0x1, 0xfb9, 0x24},
3683         /* Enable AOW0 to MW9 */
3684         {0x1, 0xfb8, 0xa8},
3685         { }
3686 };
3687
3688 static void set_widgets_power_state_vt1812(struct hda_codec *codec)
3689 {
3690         struct via_spec *spec = codec->spec;
3691         int imux_is_smixer =
3692         snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3693         unsigned int parm;
3694         unsigned int present;
3695         /* MUX10 (1eh) = stereo mixer */
3696         imux_is_smixer =
3697         snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
3698         /* inputs */
3699         /* PW 5/6/7 (29h/2ah/2bh) */
3700         parm = AC_PWRST_D3;
3701         set_pin_power_state(codec, 0x29, &parm);
3702         set_pin_power_state(codec, 0x2a, &parm);
3703         set_pin_power_state(codec, 0x2b, &parm);
3704         parm = AC_PWRST_D0;
3705         /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
3706         snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3707         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3708         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3709         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3710
3711         /* outputs */
3712         /* AOW0 (8h)*/
3713         snd_hda_codec_write(codec, 0x8, 0,
3714                             AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3715
3716         /* PW4 (28h), MW4 (18h), MUX4(38h) */
3717         parm = AC_PWRST_D3;
3718         set_pin_power_state(codec, 0x28, &parm);
3719         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3720         snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm);
3721
3722         /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3723         parm = AC_PWRST_D3;
3724         set_pin_power_state(codec, 0x25, &parm);
3725         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm);
3726         snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm);
3727         if (spec->hp_independent_mode)
3728                 snd_hda_codec_write(codec, 0x9, 0,
3729                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3730
3731         /* Internal Speaker */
3732         /* PW0 (24h), MW0(14h), MUX0(34h) */
3733         present = snd_hda_jack_detect(codec, 0x25);
3734
3735         parm = AC_PWRST_D3;
3736         set_pin_power_state(codec, 0x24, &parm);
3737         if (present) {
3738                 snd_hda_codec_write(codec, 0x14, 0,
3739                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3740                 snd_hda_codec_write(codec, 0x34, 0,
3741                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3742         } else {
3743                 snd_hda_codec_write(codec, 0x14, 0,
3744                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3745                 snd_hda_codec_write(codec, 0x34, 0,
3746                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3747         }
3748
3749
3750         /* Mono Out */
3751         /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
3752         present = snd_hda_jack_detect(codec, 0x28);
3753
3754         parm = AC_PWRST_D3;
3755         set_pin_power_state(codec, 0x31, &parm);
3756         if (present) {
3757                 snd_hda_codec_write(codec, 0x1c, 0,
3758                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3759                 snd_hda_codec_write(codec, 0x3c, 0,
3760                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3761                 snd_hda_codec_write(codec, 0x3e, 0,
3762                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3763         } else {
3764                 snd_hda_codec_write(codec, 0x1c, 0,
3765                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3766                 snd_hda_codec_write(codec, 0x3c, 0,
3767                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3768                 snd_hda_codec_write(codec, 0x3e, 0,
3769                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3770         }
3771
3772         /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
3773         parm = AC_PWRST_D3;
3774         set_pin_power_state(codec, 0x33, &parm);
3775         snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3776         snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm);
3777
3778 }
3779
3780 /* patch for vt1812 */
3781 static int patch_vt1812(struct hda_codec *codec)
3782 {
3783         struct via_spec *spec;
3784         int err;
3785
3786         /* create a codec specific record */
3787         spec = via_new_spec(codec);
3788         if (spec == NULL)
3789                 return -ENOMEM;
3790
3791         spec->aa_mix_nid = 0x21;
3792         override_mic_boost(codec, 0x2b, 0, 3, 40);
3793         override_mic_boost(codec, 0x29, 0, 3, 40);
3794         add_secret_dac_path(codec);
3795
3796         /* automatic parse from the BIOS config */
3797         err = via_parse_auto_config(codec);
3798         if (err < 0) {
3799                 via_free(codec);
3800                 return err;
3801         }
3802
3803         spec->init_verbs[spec->num_iverbs++]  = vt1812_init_verbs;
3804
3805         codec->patch_ops = via_patch_ops;
3806
3807         spec->set_widgets_power_state =  set_widgets_power_state_vt1812;
3808         return 0;
3809 }
3810
3811 /*
3812  * patch entries
3813  */
3814 static const struct hda_codec_preset snd_hda_preset_via[] = {
3815         { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3816         { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3817         { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3818         { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3819         { .id = 0x1106e710, .name = "VT1709 10-Ch",
3820           .patch = patch_vt1709},
3821         { .id = 0x1106e711, .name = "VT1709 10-Ch",
3822           .patch = patch_vt1709},
3823         { .id = 0x1106e712, .name = "VT1709 10-Ch",
3824           .patch = patch_vt1709},
3825         { .id = 0x1106e713, .name = "VT1709 10-Ch",
3826           .patch = patch_vt1709},
3827         { .id = 0x1106e714, .name = "VT1709 6-Ch",
3828           .patch = patch_vt1709},
3829         { .id = 0x1106e715, .name = "VT1709 6-Ch",
3830           .patch = patch_vt1709},
3831         { .id = 0x1106e716, .name = "VT1709 6-Ch",
3832           .patch = patch_vt1709},
3833         { .id = 0x1106e717, .name = "VT1709 6-Ch",
3834           .patch = patch_vt1709},
3835         { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3836           .patch = patch_vt1708B},
3837         { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3838           .patch = patch_vt1708B},
3839         { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3840           .patch = patch_vt1708B},
3841         { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3842           .patch = patch_vt1708B},
3843         { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3844           .patch = patch_vt1708B},
3845         { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3846           .patch = patch_vt1708B},
3847         { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3848           .patch = patch_vt1708B},
3849         { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3850           .patch = patch_vt1708B},
3851         { .id = 0x11060397, .name = "VT1708S",
3852           .patch = patch_vt1708S},
3853         { .id = 0x11061397, .name = "VT1708S",
3854           .patch = patch_vt1708S},
3855         { .id = 0x11062397, .name = "VT1708S",
3856           .patch = patch_vt1708S},
3857         { .id = 0x11063397, .name = "VT1708S",
3858           .patch = patch_vt1708S},
3859         { .id = 0x11064397, .name = "VT1705",
3860           .patch = patch_vt1708S},
3861         { .id = 0x11065397, .name = "VT1708S",
3862           .patch = patch_vt1708S},
3863         { .id = 0x11066397, .name = "VT1708S",
3864           .patch = patch_vt1708S},
3865         { .id = 0x11067397, .name = "VT1708S",
3866           .patch = patch_vt1708S},
3867         { .id = 0x11060398, .name = "VT1702",
3868           .patch = patch_vt1702},
3869         { .id = 0x11061398, .name = "VT1702",
3870           .patch = patch_vt1702},
3871         { .id = 0x11062398, .name = "VT1702",
3872           .patch = patch_vt1702},
3873         { .id = 0x11063398, .name = "VT1702",
3874           .patch = patch_vt1702},
3875         { .id = 0x11064398, .name = "VT1702",
3876           .patch = patch_vt1702},
3877         { .id = 0x11065398, .name = "VT1702",
3878           .patch = patch_vt1702},
3879         { .id = 0x11066398, .name = "VT1702",
3880           .patch = patch_vt1702},
3881         { .id = 0x11067398, .name = "VT1702",
3882           .patch = patch_vt1702},
3883         { .id = 0x11060428, .name = "VT1718S",
3884           .patch = patch_vt1718S},
3885         { .id = 0x11064428, .name = "VT1718S",
3886           .patch = patch_vt1718S},
3887         { .id = 0x11060441, .name = "VT2020",
3888           .patch = patch_vt1718S},
3889         { .id = 0x11064441, .name = "VT1828S",
3890           .patch = patch_vt1718S},
3891         { .id = 0x11060433, .name = "VT1716S",
3892           .patch = patch_vt1716S},
3893         { .id = 0x1106a721, .name = "VT1716S",
3894           .patch = patch_vt1716S},
3895         { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
3896         { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
3897         { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
3898         { .id = 0x11060440, .name = "VT1818S",
3899           .patch = patch_vt1708S},
3900         { .id = 0x11060446, .name = "VT1802",
3901                 .patch = patch_vt2002P},
3902         { .id = 0x11068446, .name = "VT1802",
3903                 .patch = patch_vt2002P},
3904         {} /* terminator */
3905 };
3906
3907 MODULE_ALIAS("snd-hda-codec-id:1106*");
3908
3909 static struct hda_codec_preset_list via_list = {
3910         .preset = snd_hda_preset_via,
3911         .owner = THIS_MODULE,
3912 };
3913
3914 MODULE_LICENSE("GPL");
3915 MODULE_DESCRIPTION("VIA HD-audio codec");
3916
3917 static int __init patch_via_init(void)
3918 {
3919         return snd_hda_add_codec_preset(&via_list);
3920 }
3921
3922 static void __exit patch_via_exit(void)
3923 {
3924         snd_hda_delete_codec_preset(&via_list);
3925 }
3926
3927 module_init(patch_via_init)
3928 module_exit(patch_via_exit)