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 = 0;
1510         codec->pcm_info = info;
1511
1512         if (spec->multiout.num_dacs || spec->num_adc_nids) {
1513                 snprintf(spec->stream_name_analog,
1514                          sizeof(spec->stream_name_analog),
1515                          "%s Analog", codec->chip_name);
1516                 info->name = spec->stream_name_analog;
1517
1518                 if (spec->multiout.num_dacs) {
1519                         if (!spec->stream_analog_playback)
1520                                 spec->stream_analog_playback =
1521                                         &via_pcm_analog_playback;
1522                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1523                                 *spec->stream_analog_playback;
1524                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1525                                 spec->multiout.dac_nids[0];
1526                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1527                                 spec->multiout.max_channels;
1528                 }
1529
1530                 if (!spec->stream_analog_capture) {
1531                         if (spec->dyn_adc_switch)
1532                                 spec->stream_analog_capture =
1533                                         &via_pcm_dyn_adc_analog_capture;
1534                         else
1535                                 spec->stream_analog_capture =
1536                                         &via_pcm_analog_capture;
1537                 }
1538                 if (spec->num_adc_nids) {
1539                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1540                                 *spec->stream_analog_capture;
1541                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1542                                 spec->adc_nids[0];
1543                         if (!spec->dyn_adc_switch)
1544                                 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
1545                                         spec->num_adc_nids;
1546                 }
1547                 codec->num_pcms++;
1548                 info++;
1549         }
1550
1551         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1552                 snprintf(spec->stream_name_digital,
1553                          sizeof(spec->stream_name_digital),
1554                          "%s Digital", codec->chip_name);
1555                 info->name = spec->stream_name_digital;
1556                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1557                 if (spec->multiout.dig_out_nid) {
1558                         if (!spec->stream_digital_playback)
1559                                 spec->stream_digital_playback =
1560                                         &via_pcm_digital_playback;
1561                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1562                                 *spec->stream_digital_playback;
1563                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1564                                 spec->multiout.dig_out_nid;
1565                 }
1566                 if (spec->dig_in_nid) {
1567                         if (!spec->stream_digital_capture)
1568                                 spec->stream_digital_capture =
1569                                         &via_pcm_digital_capture;
1570                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1571                                 *spec->stream_digital_capture;
1572                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1573                                 spec->dig_in_nid;
1574                 }
1575                 codec->num_pcms++;
1576                 info++;
1577         }
1578
1579         if (spec->hp_dac_nid) {
1580                 snprintf(spec->stream_name_hp, sizeof(spec->stream_name_hp),
1581                          "%s HP", codec->chip_name);
1582                 info->name = spec->stream_name_hp;
1583                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = via_pcm_hp_playback;
1584                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1585                         spec->hp_dac_nid;
1586                 codec->num_pcms++;
1587                 info++;
1588         }
1589         return 0;
1590 }
1591
1592 static void via_free(struct hda_codec *codec)
1593 {
1594         struct via_spec *spec = codec->spec;
1595
1596         if (!spec)
1597                 return;
1598
1599         via_free_kctls(codec);
1600         vt1708_stop_hp_work(spec);
1601         kfree(spec->bind_cap_vol);
1602         kfree(spec->bind_cap_sw);
1603         kfree(spec);
1604 }
1605
1606 /* mute/unmute outputs */
1607 static void toggle_output_mutes(struct hda_codec *codec, int num_pins,
1608                                 hda_nid_t *pins, bool mute)
1609 {
1610         int i;
1611         for (i = 0; i < num_pins; i++) {
1612                 unsigned int parm = snd_hda_codec_read(codec, pins[i], 0,
1613                                           AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1614                 if (parm & AC_PINCTL_IN_EN)
1615                         continue;
1616                 if (mute)
1617                         parm &= ~AC_PINCTL_OUT_EN;
1618                 else
1619                         parm |= AC_PINCTL_OUT_EN;
1620                 snd_hda_codec_write(codec, pins[i], 0,
1621                                     AC_VERB_SET_PIN_WIDGET_CONTROL, parm);
1622         }
1623 }
1624
1625 /* mute internal speaker if line-out is plugged */
1626 static void via_line_automute(struct hda_codec *codec, int present)
1627 {
1628         struct via_spec *spec = codec->spec;
1629
1630         if (!spec->autocfg.speaker_outs)
1631                 return;
1632         if (!present)
1633                 present = snd_hda_jack_detect(codec,
1634                                               spec->autocfg.line_out_pins[0]);
1635         toggle_output_mutes(codec, spec->autocfg.speaker_outs,
1636                             spec->autocfg.speaker_pins,
1637                             present);
1638 }
1639
1640 /* mute internal speaker if HP is plugged */
1641 static void via_hp_automute(struct hda_codec *codec)
1642 {
1643         int present = 0;
1644         int nums;
1645         struct via_spec *spec = codec->spec;
1646
1647         if (!spec->hp_independent_mode && spec->autocfg.hp_pins[0])
1648                 present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
1649
1650         if (spec->smart51_enabled)
1651                 nums = spec->autocfg.line_outs + spec->smart51_nums;
1652         else
1653                 nums = spec->autocfg.line_outs;
1654         toggle_output_mutes(codec, nums, spec->autocfg.line_out_pins, present);
1655
1656         via_line_automute(codec, present);
1657 }
1658
1659 static void via_gpio_control(struct hda_codec *codec)
1660 {
1661         unsigned int gpio_data;
1662         unsigned int vol_counter;
1663         unsigned int vol;
1664         unsigned int master_vol;
1665
1666         struct via_spec *spec = codec->spec;
1667
1668         gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
1669                                        AC_VERB_GET_GPIO_DATA, 0) & 0x03;
1670
1671         vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
1672                                           0xF84, 0) & 0x3F0000) >> 16;
1673
1674         vol = vol_counter & 0x1F;
1675         master_vol = snd_hda_codec_read(codec, 0x1A, 0,
1676                                         AC_VERB_GET_AMP_GAIN_MUTE,
1677                                         AC_AMP_GET_INPUT);
1678
1679         if (gpio_data == 0x02) {
1680                 /* unmute line out */
1681                 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1682                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1683                                     PIN_OUT);
1684                 if (vol_counter & 0x20) {
1685                         /* decrease volume */
1686                         if (vol > master_vol)
1687                                 vol = master_vol;
1688                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1689                                                  0, HDA_AMP_VOLMASK,
1690                                                  master_vol-vol);
1691                 } else {
1692                         /* increase volume */
1693                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1694                                          HDA_AMP_VOLMASK,
1695                                          ((master_vol+vol) > 0x2A) ? 0x2A :
1696                                           (master_vol+vol));
1697                 }
1698         } else if (!(gpio_data & 0x02)) {
1699                 /* mute line out */
1700                 snd_hda_codec_write(codec, spec->autocfg.line_out_pins[0], 0,
1701                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1702                                     0);
1703         }
1704 }
1705
1706 /* unsolicited event for jack sensing */
1707 static void via_unsol_event(struct hda_codec *codec,
1708                                   unsigned int res)
1709 {
1710         res >>= 26;
1711
1712         if (res & VIA_JACK_EVENT)
1713                 set_widgets_power_state(codec);
1714
1715         res &= ~VIA_JACK_EVENT;
1716
1717         if (res == VIA_HP_EVENT || res == VIA_LINE_EVENT)
1718                 via_hp_automute(codec);
1719         else if (res == VIA_GPIO_EVENT)
1720                 via_gpio_control(codec);
1721 }
1722
1723 #ifdef CONFIG_PM
1724 static int via_suspend(struct hda_codec *codec, pm_message_t state)
1725 {
1726         struct via_spec *spec = codec->spec;
1727         vt1708_stop_hp_work(spec);
1728         return 0;
1729 }
1730 #endif
1731
1732 #ifdef CONFIG_SND_HDA_POWER_SAVE
1733 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1734 {
1735         struct via_spec *spec = codec->spec;
1736         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1737 }
1738 #endif
1739
1740 /*
1741  */
1742
1743 static int via_init(struct hda_codec *codec);
1744
1745 static const struct hda_codec_ops via_patch_ops = {
1746         .build_controls = via_build_controls,
1747         .build_pcms = via_build_pcms,
1748         .init = via_init,
1749         .free = via_free,
1750         .unsol_event = via_unsol_event,
1751 #ifdef CONFIG_PM
1752         .suspend = via_suspend,
1753 #endif
1754 #ifdef CONFIG_SND_HDA_POWER_SAVE
1755         .check_power_status = via_check_power_status,
1756 #endif
1757 };
1758
1759 static bool is_empty_dac(struct hda_codec *codec, hda_nid_t dac)
1760 {
1761         struct via_spec *spec = codec->spec;
1762         int i;
1763
1764         for (i = 0; i < spec->multiout.num_dacs; i++) {
1765                 if (spec->multiout.dac_nids[i] == dac)
1766                         return false;
1767         }
1768         if (spec->hp_dac_nid == dac)
1769                 return false;
1770         return true;
1771 }
1772
1773 static bool __parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1774                                 hda_nid_t target_dac, int with_aa_mix,
1775                                 struct nid_path *path, int depth)
1776 {
1777         struct via_spec *spec = codec->spec;
1778         hda_nid_t conn[8];
1779         int i, nums;
1780
1781         if (nid == spec->aa_mix_nid) {
1782                 if (!with_aa_mix)
1783                         return false;
1784                 with_aa_mix = 2; /* mark aa-mix is included */
1785         }
1786
1787         nums = snd_hda_get_connections(codec, nid, conn, ARRAY_SIZE(conn));
1788         for (i = 0; i < nums; i++) {
1789                 if (get_wcaps_type(get_wcaps(codec, conn[i])) != AC_WID_AUD_OUT)
1790                         continue;
1791                 if (conn[i] == target_dac || is_empty_dac(codec, conn[i])) {
1792                         /* aa-mix is requested but not included? */
1793                         if (!(spec->aa_mix_nid && with_aa_mix == 1))
1794                                 goto found;
1795                 }
1796         }
1797         if (depth >= MAX_NID_PATH_DEPTH)
1798                 return false;
1799         for (i = 0; i < nums; i++) {
1800                 unsigned int type;
1801                 type = get_wcaps_type(get_wcaps(codec, conn[i]));
1802                 if (type == AC_WID_AUD_OUT)
1803                         continue;
1804                 if (__parse_output_path(codec, conn[i], target_dac,
1805                                         with_aa_mix, path, depth + 1))
1806                         goto found;
1807         }
1808         return false;
1809
1810  found:
1811         path->path[path->depth] = conn[i];
1812         path->idx[path->depth] = i;
1813         if (nums > 1 && get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_AUD_MIX)
1814                 path->multi[path->depth] = 1;
1815         path->depth++;
1816         return true;
1817 }
1818
1819 static bool parse_output_path(struct hda_codec *codec, hda_nid_t nid,
1820                               hda_nid_t target_dac, int with_aa_mix,
1821                               struct nid_path *path)
1822 {
1823         if (__parse_output_path(codec, nid, target_dac, with_aa_mix, path, 1)) {
1824                 path->path[path->depth] = nid;
1825                 path->depth++;
1826                 snd_printdd("output-path: depth=%d, %02x/%02x/%02x/%02x/%02x\n",
1827                             path->depth, path->path[0], path->path[1],
1828                             path->path[2], path->path[3], path->path[4]);
1829                 return true;
1830         }
1831         return false;
1832 }
1833
1834 static int via_auto_fill_dac_nids(struct hda_codec *codec)
1835 {
1836         struct via_spec *spec = codec->spec;
1837         const struct auto_pin_cfg *cfg = &spec->autocfg;
1838         int i, dac_num;
1839         hda_nid_t nid;
1840
1841         spec->multiout.dac_nids = spec->private_dac_nids;
1842         dac_num = 0;
1843         for (i = 0; i < cfg->line_outs; i++) {
1844                 hda_nid_t dac = 0;
1845                 nid = cfg->line_out_pins[i];
1846                 if (!nid)
1847                         continue;
1848                 if (parse_output_path(codec, nid, 0, 0, &spec->out_path[i]))
1849                         dac = spec->out_path[i].path[0];
1850                 if (!i && parse_output_path(codec, nid, dac, 1,
1851                                             &spec->out_mix_path))
1852                         dac = spec->out_mix_path.path[0];
1853                 if (dac) {
1854                         spec->private_dac_nids[i] = dac;
1855                         dac_num++;
1856                 }
1857         }
1858         if (!spec->out_path[0].depth && spec->out_mix_path.depth) {
1859                 spec->out_path[0] = spec->out_mix_path;
1860                 spec->out_mix_path.depth = 0;
1861         }
1862         spec->multiout.num_dacs = dac_num;
1863         return 0;
1864 }
1865
1866 static int create_ch_ctls(struct hda_codec *codec, const char *pfx,
1867                           int chs, bool check_dac, struct nid_path *path)
1868 {
1869         struct via_spec *spec = codec->spec;
1870         char name[32];
1871         hda_nid_t dac, pin, sel, nid;
1872         int err;
1873
1874         dac = check_dac ? path->path[0] : 0;
1875         pin = path->path[path->depth - 1];
1876         sel = path->depth > 1 ? path->path[1] : 0;
1877
1878         if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1879                 nid = dac;
1880         else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1881                 nid = pin;
1882         else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_NUM_STEPS))
1883                 nid = sel;
1884         else
1885                 nid = 0;
1886         if (nid) {
1887                 sprintf(name, "%s Playback Volume", pfx);
1888                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1889                               HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1890                 if (err < 0)
1891                         return err;
1892                 path->vol_ctl = nid;
1893         }
1894
1895         if (dac && check_amp_caps(codec, dac, HDA_OUTPUT, AC_AMPCAP_MUTE))
1896                 nid = dac;
1897         else if (check_amp_caps(codec, pin, HDA_OUTPUT, AC_AMPCAP_MUTE))
1898                 nid = pin;
1899         else if (check_amp_caps(codec, sel, HDA_OUTPUT, AC_AMPCAP_MUTE))
1900                 nid = sel;
1901         else
1902                 nid = 0;
1903         if (nid) {
1904                 sprintf(name, "%s Playback Switch", pfx);
1905                 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1906                               HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
1907                 if (err < 0)
1908                         return err;
1909                 path->mute_ctl = nid;
1910         }
1911         return 0;
1912 }
1913
1914 static void mangle_smart51(struct hda_codec *codec)
1915 {
1916         struct via_spec *spec = codec->spec;
1917         struct auto_pin_cfg *cfg = &spec->autocfg;
1918         struct auto_pin_cfg_item *ins = cfg->inputs;
1919         int i, j, nums, attr;
1920         int pins[AUTO_CFG_MAX_INS];
1921
1922         for (attr = INPUT_PIN_ATTR_REAR; attr >= INPUT_PIN_ATTR_NORMAL; attr--) {
1923                 nums = 0;
1924                 for (i = 0; i < cfg->num_inputs; i++) {
1925                         unsigned int def;
1926                         if (ins[i].type > AUTO_PIN_LINE_IN)
1927                                 continue;
1928                         def = snd_hda_codec_get_pincfg(codec, ins[i].pin);
1929                         if (snd_hda_get_input_pin_attr(def) != attr)
1930                                 continue;
1931                         for (j = 0; j < nums; j++)
1932                                 if (ins[pins[j]].type < ins[i].type) {
1933                                         memmove(pins + j + 1, pins + j,
1934                                                 (nums - j) * sizeof(int));
1935                                         break;
1936                                 }
1937                         pins[j] = i;
1938                         nums++;
1939                 }
1940                 if (cfg->line_outs + nums < 3)
1941                         continue;
1942                 for (i = 0; i < nums; i++) {
1943                         hda_nid_t pin = ins[pins[i]].pin;
1944                         spec->smart51_pins[spec->smart51_nums++] = pin;
1945                         cfg->line_out_pins[cfg->line_outs++] = pin;
1946                         if (cfg->line_outs == 3)
1947                                 break;
1948                 }
1949                 return;
1950         }
1951 }
1952
1953 static void copy_path_mixer_ctls(struct nid_path *dst, struct nid_path *src)
1954 {
1955         dst->vol_ctl = src->vol_ctl;
1956         dst->mute_ctl = src->mute_ctl;
1957 }
1958
1959 /* add playback controls from the parsed DAC table */
1960 static int via_auto_create_multi_out_ctls(struct hda_codec *codec)
1961 {
1962         struct via_spec *spec = codec->spec;
1963         struct auto_pin_cfg *cfg = &spec->autocfg;
1964         struct nid_path *path;
1965         static const char * const chname[4] = {
1966                 "Front", "Surround", "C/LFE", "Side"
1967         };
1968         int i, idx, err;
1969         int old_line_outs;
1970
1971         /* check smart51 */
1972         old_line_outs = cfg->line_outs;
1973         if (cfg->line_outs == 1)
1974                 mangle_smart51(codec);
1975
1976         err = via_auto_fill_dac_nids(codec);
1977         if (err < 0)
1978                 return err;
1979
1980         if (spec->multiout.num_dacs < 3) {
1981                 spec->smart51_nums = 0;
1982                 cfg->line_outs = old_line_outs;
1983         }
1984         for (i = 0; i < cfg->line_outs; i++) {
1985                 hda_nid_t pin, dac;
1986                 pin = cfg->line_out_pins[i];
1987                 dac = spec->multiout.dac_nids[i];
1988                 if (!pin || !dac)
1989                         continue;
1990                 path = spec->out_path + i;
1991                 if (i == HDA_CLFE) {
1992                         err = create_ch_ctls(codec, "Center", 1, true, path);
1993                         if (err < 0)
1994                                 return err;
1995                         err = create_ch_ctls(codec, "LFE", 2, true, path);
1996                         if (err < 0)
1997                                 return err;
1998                 } else {
1999                         const char *pfx = chname[i];
2000                         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT &&
2001                             cfg->line_outs == 1)
2002                                 pfx = "Speaker";
2003                         err = create_ch_ctls(codec, pfx, 3, true, path);
2004                         if (err < 0)
2005                                 return err;
2006                 }
2007                 if (path != spec->out_path + i)
2008                         copy_path_mixer_ctls(&spec->out_path[i], path);
2009                 if (path == spec->out_path && spec->out_mix_path.depth)
2010                         copy_path_mixer_ctls(&spec->out_mix_path, path);
2011         }
2012
2013         idx = get_connection_index(codec, spec->aa_mix_nid,
2014                                    spec->multiout.dac_nids[0]);
2015         if (idx >= 0) {
2016                 /* add control to mixer */
2017                 const char *name;
2018                 name = spec->out_mix_path.depth ?
2019                         "PCM Loopback Playback Volume" : "PCM Playback Volume";
2020                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2021                                       HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2022                                                           idx, HDA_INPUT));
2023                 if (err < 0)
2024                         return err;
2025                 name = spec->out_mix_path.depth ?
2026                         "PCM Loopback Playback Switch" : "PCM Playback Switch";
2027                 err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2028                                       HDA_COMPOSE_AMP_VAL(spec->aa_mix_nid, 3,
2029                                                           idx, HDA_INPUT));
2030                 if (err < 0)
2031                         return err;
2032         }
2033
2034         cfg->line_outs = old_line_outs;
2035
2036         return 0;
2037 }
2038
2039 static int via_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
2040 {
2041         struct via_spec *spec = codec->spec;
2042         struct nid_path *path;
2043         bool check_dac;
2044         int i, err;
2045
2046         if (!pin)
2047                 return 0;
2048
2049         if (!parse_output_path(codec, pin, 0, 0, &spec->hp_indep_path)) {
2050                 for (i = HDA_SIDE; i >= HDA_CLFE; i--) {
2051                         if (i < spec->multiout.num_dacs &&
2052                             parse_output_path(codec, pin,
2053                                               spec->multiout.dac_nids[i], 0,
2054                                               &spec->hp_indep_path)) {
2055                                 spec->hp_indep_shared = i;
2056                                 break;
2057                         }
2058                 }
2059         }
2060         if (spec->hp_indep_path.depth) {
2061                 spec->hp_dac_nid = spec->hp_indep_path.path[0];
2062                 if (!spec->hp_indep_shared)
2063                         spec->hp_path = spec->hp_indep_path;
2064         }
2065         /* optionally check front-path w/o AA-mix */
2066         if (!spec->hp_path.depth)
2067                 parse_output_path(codec, pin,
2068                                   spec->multiout.dac_nids[HDA_FRONT], 0,
2069                                   &spec->hp_path);
2070
2071         if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2072                                1, &spec->hp_mix_path) && !spec->hp_path.depth)
2073                 return 0;
2074
2075         if (spec->hp_path.depth) {
2076                 path = &spec->hp_path;
2077                 check_dac = true;
2078         } else {
2079                 path = &spec->hp_mix_path;
2080                 check_dac = false;
2081         }
2082         err = create_ch_ctls(codec, "Headphone", 3, check_dac, path);
2083         if (err < 0)
2084                 return err;
2085         if (check_dac)
2086                 copy_path_mixer_ctls(&spec->hp_mix_path, path);
2087         else
2088                 copy_path_mixer_ctls(&spec->hp_path, path);
2089         if (spec->hp_indep_path.depth)
2090                 copy_path_mixer_ctls(&spec->hp_indep_path, path);
2091         return 0;
2092 }
2093
2094 static int via_auto_create_speaker_ctls(struct hda_codec *codec)
2095 {
2096         struct via_spec *spec = codec->spec;
2097         struct nid_path *path;
2098         bool check_dac;
2099         hda_nid_t pin, dac = 0;
2100         int err;
2101
2102         pin = spec->autocfg.speaker_pins[0];
2103         if (!spec->autocfg.speaker_outs || !pin)
2104                 return 0;
2105
2106         if (parse_output_path(codec, pin, 0, 0, &spec->speaker_path))
2107                 dac = spec->speaker_path.path[0];
2108         if (!dac)
2109                 parse_output_path(codec, pin,
2110                                   spec->multiout.dac_nids[HDA_FRONT], 0,
2111                                   &spec->speaker_path);
2112         if (!parse_output_path(codec, pin, spec->multiout.dac_nids[HDA_FRONT],
2113                                1, &spec->speaker_mix_path) && !dac)
2114                 return 0;
2115
2116         /* no AA-path for front? */
2117         if (!spec->out_mix_path.depth && spec->speaker_mix_path.depth)
2118                 dac = 0;
2119
2120         spec->speaker_dac_nid = dac;
2121         spec->multiout.extra_out_nid[0] = dac;
2122         if (dac) {
2123                 path = &spec->speaker_path;
2124                 check_dac = true;
2125         } else {
2126                 path = &spec->speaker_mix_path;
2127                 check_dac = false;
2128         }
2129         err = create_ch_ctls(codec, "Speaker", 3, check_dac, path);
2130         if (err < 0)
2131                 return err;
2132         if (check_dac)
2133                 copy_path_mixer_ctls(&spec->speaker_mix_path, path);
2134         else
2135                 copy_path_mixer_ctls(&spec->speaker_path, path);
2136         return 0;
2137 }
2138
2139 #define via_aamix_ctl_info      via_pin_power_ctl_info
2140
2141 static int via_aamix_ctl_get(struct snd_kcontrol *kcontrol,
2142                              struct snd_ctl_elem_value *ucontrol)
2143 {
2144         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2145         struct via_spec *spec = codec->spec;
2146         ucontrol->value.enumerated.item[0] = spec->aamix_mode;
2147         return 0;
2148 }
2149
2150 static void update_aamix_paths(struct hda_codec *codec, int do_mix,
2151                                struct nid_path *nomix, struct nid_path *mix)
2152 {
2153         if (do_mix) {
2154                 activate_output_path(codec, nomix, false, false);
2155                 activate_output_path(codec, mix, true, false);
2156         } else {
2157                 activate_output_path(codec, mix, false, false);
2158                 activate_output_path(codec, nomix, true, false);
2159         }
2160 }
2161
2162 static int via_aamix_ctl_put(struct snd_kcontrol *kcontrol,
2163                              struct snd_ctl_elem_value *ucontrol)
2164 {
2165         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2166         struct via_spec *spec = codec->spec;
2167         unsigned int val = ucontrol->value.enumerated.item[0];
2168
2169         if (val == spec->aamix_mode)
2170                 return 0;
2171         spec->aamix_mode = val;
2172         /* update front path */
2173         update_aamix_paths(codec, val, &spec->out_path[0], &spec->out_mix_path);
2174         /* update HP path */
2175         if (!spec->hp_independent_mode) {
2176                 update_aamix_paths(codec, val, &spec->hp_path,
2177                                    &spec->hp_mix_path);
2178         }
2179         /* update speaker path */
2180         update_aamix_paths(codec, val, &spec->speaker_path,
2181                            &spec->speaker_mix_path);
2182         return 1;
2183 }
2184
2185 static const struct snd_kcontrol_new via_aamix_ctl_enum = {
2186         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2187         .name = "Loopback Mixing",
2188         .info = via_aamix_ctl_info,
2189         .get = via_aamix_ctl_get,
2190         .put = via_aamix_ctl_put,
2191 };
2192
2193 static int via_auto_create_loopback_switch(struct hda_codec *codec)
2194 {
2195         struct via_spec *spec = codec->spec;
2196
2197         if (!spec->aa_mix_nid || !spec->out_mix_path.depth)
2198                 return 0; /* no loopback switching available */
2199         if (!via_clone_control(spec, &via_aamix_ctl_enum))
2200                 return -ENOMEM;
2201         return 0;
2202 }
2203
2204 /* look for ADCs */
2205 static int via_fill_adcs(struct hda_codec *codec)
2206 {
2207         struct via_spec *spec = codec->spec;
2208         hda_nid_t nid = codec->start_nid;
2209         int i;
2210
2211         for (i = 0; i < codec->num_nodes; i++, nid++) {
2212                 unsigned int wcaps = get_wcaps(codec, nid);
2213                 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
2214                         continue;
2215                 if (wcaps & AC_WCAP_DIGITAL)
2216                         continue;
2217                 if (!(wcaps & AC_WCAP_CONN_LIST))
2218                         continue;
2219                 if (spec->num_adc_nids >= ARRAY_SIZE(spec->adc_nids))
2220                         return -ENOMEM;
2221                 spec->adc_nids[spec->num_adc_nids++] = nid;
2222         }
2223         return 0;
2224 }
2225
2226 /* input-src control */
2227 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
2228                              struct snd_ctl_elem_info *uinfo)
2229 {
2230         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2231         struct via_spec *spec = codec->spec;
2232
2233         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2234         uinfo->count = 1;
2235         uinfo->value.enumerated.items = spec->num_inputs;
2236         if (uinfo->value.enumerated.item >= spec->num_inputs)
2237                 uinfo->value.enumerated.item = spec->num_inputs - 1;
2238         strcpy(uinfo->value.enumerated.name,
2239                spec->inputs[uinfo->value.enumerated.item].label);
2240         return 0;
2241 }
2242
2243 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
2244                             struct snd_ctl_elem_value *ucontrol)
2245 {
2246         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2247         struct via_spec *spec = codec->spec;
2248         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2249
2250         ucontrol->value.enumerated.item[0] = spec->cur_mux[idx];
2251         return 0;
2252 }
2253
2254 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
2255                             struct snd_ctl_elem_value *ucontrol)
2256 {
2257         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2258         struct via_spec *spec = codec->spec;
2259         unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2260         hda_nid_t mux;
2261         int cur;
2262
2263         cur = ucontrol->value.enumerated.item[0];
2264         if (cur < 0 || cur >= spec->num_inputs)
2265                 return -EINVAL;
2266         if (spec->cur_mux[idx] == cur)
2267                 return 0;
2268         spec->cur_mux[idx] = cur;
2269         if (spec->dyn_adc_switch) {
2270                 int adc_idx = spec->inputs[cur].adc_idx;
2271                 mux = spec->mux_nids[adc_idx];
2272                 via_dyn_adc_pcm_resetup(codec, cur);
2273         } else {
2274                 mux = spec->mux_nids[idx];
2275                 if (snd_BUG_ON(!mux))
2276                         return -EINVAL;
2277         }
2278
2279         if (mux) {
2280                 /* switch to D0 beofre change index */
2281                 if (snd_hda_codec_read(codec, mux, 0,
2282                                AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
2283                         snd_hda_codec_write(codec, mux, 0,
2284                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2285                 snd_hda_codec_write(codec, mux, 0,
2286                                     AC_VERB_SET_CONNECT_SEL,
2287                                     spec->inputs[cur].mux_idx);
2288         }
2289
2290         /* update jack power state */
2291         set_widgets_power_state(codec);
2292         return 0;
2293 }
2294
2295 static const struct snd_kcontrol_new via_input_src_ctl = {
2296         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2297         /* The multiple "Capture Source" controls confuse alsamixer
2298          * So call somewhat different..
2299          */
2300         /* .name = "Capture Source", */
2301         .name = "Input Source",
2302         .info = via_mux_enum_info,
2303         .get = via_mux_enum_get,
2304         .put = via_mux_enum_put,
2305 };
2306
2307 static int create_input_src_ctls(struct hda_codec *codec, int count)
2308 {
2309         struct via_spec *spec = codec->spec;
2310         struct snd_kcontrol_new *knew;
2311
2312         if (spec->num_inputs <= 1 || !count)
2313                 return 0; /* no need for single src */
2314
2315         knew = via_clone_control(spec, &via_input_src_ctl);
2316         if (!knew)
2317                 return -ENOMEM;
2318         knew->count = count;
2319         return 0;
2320 }
2321
2322 /* add the powersave loopback-list entry */
2323 static void add_loopback_list(struct via_spec *spec, hda_nid_t mix, int idx)
2324 {
2325         struct hda_amp_list *list;
2326
2327         if (spec->num_loopbacks >= ARRAY_SIZE(spec->loopback_list) - 1)
2328                 return;
2329         list = spec->loopback_list + spec->num_loopbacks;
2330         list->nid = mix;
2331         list->dir = HDA_INPUT;
2332         list->idx = idx;
2333         spec->num_loopbacks++;
2334         spec->loopback.amplist = spec->loopback_list;
2335 }
2336
2337 static bool is_reachable_nid(struct hda_codec *codec, hda_nid_t src,
2338                              hda_nid_t dst)
2339 {
2340         return snd_hda_get_conn_index(codec, src, dst, 1) >= 0;
2341 }
2342
2343 /* add the input-route to the given pin */
2344 static bool add_input_route(struct hda_codec *codec, hda_nid_t pin)
2345 {
2346         struct via_spec *spec = codec->spec;
2347         int c, idx;
2348
2349         spec->inputs[spec->num_inputs].adc_idx = -1;
2350         spec->inputs[spec->num_inputs].pin = pin;
2351         for (c = 0; c < spec->num_adc_nids; c++) {
2352                 if (spec->mux_nids[c]) {
2353                         idx = get_connection_index(codec, spec->mux_nids[c],
2354                                                    pin);
2355                         if (idx < 0)
2356                                 continue;
2357                         spec->inputs[spec->num_inputs].mux_idx = idx;
2358                 } else {
2359                         if (!is_reachable_nid(codec, spec->adc_nids[c], pin))
2360                                 continue;
2361                 }
2362                 spec->inputs[spec->num_inputs].adc_idx = c;
2363                 /* Can primary ADC satisfy all inputs? */
2364                 if (!spec->dyn_adc_switch &&
2365                     spec->num_inputs > 0 && spec->inputs[0].adc_idx != c) {
2366                         snd_printd(KERN_INFO
2367                                    "via: dynamic ADC switching enabled\n");
2368                         spec->dyn_adc_switch = 1;
2369                 }
2370                 return true;
2371         }
2372         return false;
2373 }
2374
2375 static int get_mux_nids(struct hda_codec *codec);
2376
2377 /* parse input-routes; fill ADCs, MUXs and input-src entries */
2378 static int parse_analog_inputs(struct hda_codec *codec)
2379 {
2380         struct via_spec *spec = codec->spec;
2381         const struct auto_pin_cfg *cfg = &spec->autocfg;
2382         int i, err;
2383
2384         err = via_fill_adcs(codec);
2385         if (err < 0)
2386                 return err;
2387         err = get_mux_nids(codec);
2388         if (err < 0)
2389                 return err;
2390
2391         /* fill all input-routes */
2392         for (i = 0; i < cfg->num_inputs; i++) {
2393                 if (add_input_route(codec, cfg->inputs[i].pin))
2394                         spec->inputs[spec->num_inputs++].label =
2395                                 hda_get_autocfg_input_label(codec, cfg, i);
2396         }
2397
2398         /* check for internal loopback recording */
2399         if (spec->aa_mix_nid &&
2400             add_input_route(codec, spec->aa_mix_nid))
2401                 spec->inputs[spec->num_inputs++].label = "Stereo Mixer";
2402
2403         return 0;
2404 }
2405
2406 /* create analog-loopback volume/switch controls */
2407 static int create_loopback_ctls(struct hda_codec *codec)
2408 {
2409         struct via_spec *spec = codec->spec;
2410         const struct auto_pin_cfg *cfg = &spec->autocfg;
2411         const char *prev_label = NULL;
2412         int type_idx = 0;
2413         int i, j, err, idx;
2414
2415         if (!spec->aa_mix_nid)
2416                 return 0;
2417
2418         for (i = 0; i < cfg->num_inputs; i++) {
2419                 hda_nid_t pin = cfg->inputs[i].pin;
2420                 const char *label = hda_get_autocfg_input_label(codec, cfg, i);
2421
2422                 if (prev_label && !strcmp(label, prev_label))
2423                         type_idx++;
2424                 else
2425                         type_idx = 0;
2426                 prev_label = label;
2427                 idx = get_connection_index(codec, spec->aa_mix_nid, pin);
2428                 if (idx >= 0) {
2429                         err = via_new_analog_input(spec, label, type_idx,
2430                                                    idx, spec->aa_mix_nid);
2431                         if (err < 0)
2432                                 return err;
2433                         add_loopback_list(spec, spec->aa_mix_nid, idx);
2434                 }
2435
2436                 /* remember the label for smart51 control */
2437                 for (j = 0; j < spec->smart51_nums; j++) {
2438                         if (spec->smart51_pins[j] == pin) {
2439                                 spec->smart51_idxs[j] = idx;
2440                                 spec->smart51_labels[j] = label;
2441                                 break;
2442                         }
2443                 }
2444         }
2445         return 0;
2446 }
2447
2448 /* create mic-boost controls (if present) */
2449 static int create_mic_boost_ctls(struct hda_codec *codec)
2450 {
2451         struct via_spec *spec = codec->spec;
2452         const struct auto_pin_cfg *cfg = &spec->autocfg;
2453         int i, err;
2454
2455         for (i = 0; i < cfg->num_inputs; i++) {
2456                 hda_nid_t pin = cfg->inputs[i].pin;
2457                 unsigned int caps;
2458                 const char *label;
2459                 char name[32];
2460
2461                 if (cfg->inputs[i].type != AUTO_PIN_MIC)
2462                         continue;
2463                 caps = query_amp_caps(codec, pin, HDA_INPUT);
2464                 if (caps == -1 || !(caps & AC_AMPCAP_NUM_STEPS))
2465                         continue;
2466                 label = hda_get_autocfg_input_label(codec, cfg, i);
2467                 snprintf(name, sizeof(name), "%s Boost Volume", label);
2468                 err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2469                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT));
2470                 if (err < 0)
2471                         return err;
2472         }
2473         return 0;
2474 }
2475
2476 /* create capture and input-src controls for multiple streams */
2477 static int create_multi_adc_ctls(struct hda_codec *codec)
2478 {
2479         struct via_spec *spec = codec->spec;
2480         int i, err;
2481
2482         /* create capture mixer elements */
2483         for (i = 0; i < spec->num_adc_nids; i++) {
2484                 hda_nid_t adc = spec->adc_nids[i];
2485                 err = __via_add_control(spec, VIA_CTL_WIDGET_VOL,
2486                                         "Capture Volume", i,
2487                                         HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2488                                                             HDA_INPUT));
2489                 if (err < 0)
2490                         return err;
2491                 err = __via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2492                                         "Capture Switch", i,
2493                                         HDA_COMPOSE_AMP_VAL(adc, 3, 0,
2494                                                             HDA_INPUT));
2495                 if (err < 0)
2496                         return err;
2497         }
2498
2499         /* input-source control */
2500         for (i = 0; i < spec->num_adc_nids; i++)
2501                 if (!spec->mux_nids[i])
2502                         break;
2503         err = create_input_src_ctls(codec, i);
2504         if (err < 0)
2505                 return err;
2506         return 0;
2507 }
2508
2509 /* bind capture volume/switch */
2510 static struct snd_kcontrol_new via_bind_cap_vol_ctl =
2511         HDA_BIND_VOL("Capture Volume", 0);
2512 static struct snd_kcontrol_new via_bind_cap_sw_ctl =
2513         HDA_BIND_SW("Capture Switch", 0);
2514
2515 static int init_bind_ctl(struct via_spec *spec, struct hda_bind_ctls **ctl_ret,
2516                          struct hda_ctl_ops *ops)
2517 {
2518         struct hda_bind_ctls *ctl;
2519         int i;
2520
2521         ctl = kzalloc(sizeof(*ctl) + sizeof(long) * 4, GFP_KERNEL);
2522         if (!ctl)
2523                 return -ENOMEM;
2524         ctl->ops = ops;
2525         for (i = 0; i < spec->num_adc_nids; i++)
2526                 ctl->values[i] =
2527                         HDA_COMPOSE_AMP_VAL(spec->adc_nids[i], 3, 0, HDA_INPUT);
2528         *ctl_ret = ctl;
2529         return 0;
2530 }
2531
2532 /* create capture and input-src controls for dynamic ADC-switch case */
2533 static int create_dyn_adc_ctls(struct hda_codec *codec)
2534 {
2535         struct via_spec *spec = codec->spec;
2536         struct snd_kcontrol_new *knew;
2537         int err;
2538
2539         /* set up the bind capture ctls */
2540         err = init_bind_ctl(spec, &spec->bind_cap_vol, &snd_hda_bind_vol);
2541         if (err < 0)
2542                 return err;
2543         err = init_bind_ctl(spec, &spec->bind_cap_sw, &snd_hda_bind_sw);
2544         if (err < 0)
2545                 return err;
2546
2547         /* create capture mixer elements */
2548         knew = via_clone_control(spec, &via_bind_cap_vol_ctl);
2549         if (!knew)
2550                 return -ENOMEM;
2551         knew->private_value = (long)spec->bind_cap_vol;
2552
2553         knew = via_clone_control(spec, &via_bind_cap_sw_ctl);
2554         if (!knew)
2555                 return -ENOMEM;
2556         knew->private_value = (long)spec->bind_cap_sw;
2557
2558         /* input-source control */
2559         err = create_input_src_ctls(codec, 1);
2560         if (err < 0)
2561                 return err;
2562         return 0;
2563 }
2564
2565 /* parse and create capture-related stuff */
2566 static int via_auto_create_analog_input_ctls(struct hda_codec *codec)
2567 {
2568         struct via_spec *spec = codec->spec;
2569         int err;
2570
2571         err = parse_analog_inputs(codec);
2572         if (err < 0)
2573                 return err;
2574         if (spec->dyn_adc_switch)
2575                 err = create_dyn_adc_ctls(codec);
2576         else
2577                 err = create_multi_adc_ctls(codec);
2578         if (err < 0)
2579                 return err;
2580         err = create_loopback_ctls(codec);
2581         if (err < 0)
2582                 return err;
2583         err = create_mic_boost_ctls(codec);
2584         if (err < 0)
2585                 return err;
2586         return 0;
2587 }
2588
2589 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
2590 {
2591         unsigned int def_conf;
2592         unsigned char seqassoc;
2593
2594         def_conf = snd_hda_codec_get_pincfg(codec, nid);
2595         seqassoc = (unsigned char) get_defcfg_association(def_conf);
2596         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2597         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
2598             && (seqassoc == 0xf0 || seqassoc == 0xff)) {
2599                 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2600                 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2601         }
2602
2603         return;
2604 }
2605
2606 static int vt1708_jack_detect_get(struct snd_kcontrol *kcontrol,
2607                                      struct snd_ctl_elem_value *ucontrol)
2608 {
2609         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2610         struct via_spec *spec = codec->spec;
2611
2612         if (spec->codec_type != VT1708)
2613                 return 0;
2614         spec->vt1708_jack_detect =
2615                 !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
2616         ucontrol->value.integer.value[0] = spec->vt1708_jack_detect;
2617         return 0;
2618 }
2619
2620 static int vt1708_jack_detect_put(struct snd_kcontrol *kcontrol,
2621                                      struct snd_ctl_elem_value *ucontrol)
2622 {
2623         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2624         struct via_spec *spec = codec->spec;
2625         int change;
2626
2627         if (spec->codec_type != VT1708)
2628                 return 0;
2629         spec->vt1708_jack_detect = ucontrol->value.integer.value[0];
2630         change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
2631                 == !spec->vt1708_jack_detect;
2632         if (spec->vt1708_jack_detect) {
2633                 mute_aa_path(codec, 1);
2634                 notify_aa_path_ctls(codec);
2635         }
2636         return change;
2637 }
2638
2639 static const struct snd_kcontrol_new vt1708_jack_detect_ctl = {
2640         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2641         .name = "Jack Detect",
2642         .count = 1,
2643         .info = snd_ctl_boolean_mono_info,
2644         .get = vt1708_jack_detect_get,
2645         .put = vt1708_jack_detect_put,
2646 };
2647
2648 static void fill_dig_outs(struct hda_codec *codec);
2649 static void fill_dig_in(struct hda_codec *codec);
2650
2651 static int via_parse_auto_config(struct hda_codec *codec)
2652 {
2653         struct via_spec *spec = codec->spec;
2654         int err;
2655
2656         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2657         if (err < 0)
2658                 return err;
2659         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2660                 return -EINVAL;
2661
2662         err = via_auto_create_multi_out_ctls(codec);
2663         if (err < 0)
2664                 return err;
2665         err = via_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
2666         if (err < 0)
2667                 return err;
2668         err = via_auto_create_speaker_ctls(codec);
2669         if (err < 0)
2670                 return err;
2671         err = via_auto_create_loopback_switch(codec);
2672         if (err < 0)
2673                 return err;
2674         err = via_auto_create_analog_input_ctls(codec);
2675         if (err < 0)
2676                 return err;
2677
2678         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2679
2680         fill_dig_outs(codec);
2681         fill_dig_in(codec);
2682
2683         if (spec->kctls.list)
2684                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2685
2686
2687         if (spec->hp_dac_nid && spec->hp_mix_path.depth) {
2688                 err = via_hp_build(codec);
2689                 if (err < 0)
2690                         return err;
2691         }
2692
2693         err = via_smart51_build(codec);
2694         if (err < 0)
2695                 return err;
2696
2697         /* assign slave outs */
2698         if (spec->slave_dig_outs[0])
2699                 codec->slave_dig_outs = spec->slave_dig_outs;
2700
2701         return 1;
2702 }
2703
2704 static void via_auto_init_dig_outs(struct hda_codec *codec)
2705 {
2706         struct via_spec *spec = codec->spec;
2707         if (spec->multiout.dig_out_nid)
2708                 init_output_pin(codec, spec->autocfg.dig_out_pins[0], PIN_OUT);
2709         if (spec->slave_dig_outs[0])
2710                 init_output_pin(codec, spec->autocfg.dig_out_pins[1], PIN_OUT);
2711 }
2712
2713 static void via_auto_init_dig_in(struct hda_codec *codec)
2714 {
2715         struct via_spec *spec = codec->spec;
2716         if (!spec->dig_in_nid)
2717                 return;
2718         snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2719                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2720 }
2721
2722 /* initialize the unsolicited events */
2723 static void via_auto_init_unsol_event(struct hda_codec *codec)
2724 {
2725         struct via_spec *spec = codec->spec;
2726         struct auto_pin_cfg *cfg = &spec->autocfg;
2727         unsigned int ev;
2728         int i;
2729
2730         if (cfg->hp_pins[0] && is_jack_detectable(codec, cfg->hp_pins[0]))
2731                 snd_hda_codec_write(codec, cfg->hp_pins[0], 0,
2732                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2733                                 AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT);
2734
2735         if (cfg->speaker_pins[0])
2736                 ev = VIA_LINE_EVENT;
2737         else
2738                 ev = 0;
2739         for (i = 0; i < cfg->line_outs; i++) {
2740                 if (cfg->line_out_pins[i] &&
2741                     is_jack_detectable(codec, cfg->line_out_pins[i]))
2742                         snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
2743                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2744                                 AC_USRSP_EN | ev | VIA_JACK_EVENT);
2745         }
2746
2747         for (i = 0; i < cfg->num_inputs; i++) {
2748                 if (is_jack_detectable(codec, cfg->inputs[i].pin))
2749                         snd_hda_codec_write(codec, cfg->inputs[i].pin, 0,
2750                                 AC_VERB_SET_UNSOLICITED_ENABLE,
2751                                 AC_USRSP_EN | VIA_JACK_EVENT);
2752         }
2753 }
2754
2755 static int via_init(struct hda_codec *codec)
2756 {
2757         struct via_spec *spec = codec->spec;
2758         int i;
2759
2760         for (i = 0; i < spec->num_iverbs; i++)
2761                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2762
2763         via_auto_init_multi_out(codec);
2764         via_auto_init_hp_out(codec);
2765         via_auto_init_speaker_out(codec);
2766         via_auto_init_analog_input(codec);
2767         via_auto_init_dig_outs(codec);
2768         via_auto_init_dig_in(codec);
2769
2770         via_auto_init_unsol_event(codec);
2771
2772         via_hp_automute(codec);
2773
2774         return 0;
2775 }
2776
2777 static void vt1708_update_hp_jack_state(struct work_struct *work)
2778 {
2779         struct via_spec *spec = container_of(work, struct via_spec,
2780                                              vt1708_hp_work.work);
2781         if (spec->codec_type != VT1708)
2782                 return;
2783         /* if jack state toggled */
2784         if (spec->vt1708_hp_present
2785             != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2786                 spec->vt1708_hp_present ^= 1;
2787                 via_hp_automute(spec->codec);
2788         }
2789         vt1708_start_hp_work(spec);
2790 }
2791
2792 static int get_mux_nids(struct hda_codec *codec)
2793 {
2794         struct via_spec *spec = codec->spec;
2795         hda_nid_t nid, conn[8];
2796         unsigned int type;
2797         int i, n;
2798
2799         for (i = 0; i < spec->num_adc_nids; i++) {
2800                 nid = spec->adc_nids[i];
2801                 while (nid) {
2802                         type = get_wcaps_type(get_wcaps(codec, nid));
2803                         if (type == AC_WID_PIN)
2804                                 break;
2805                         n = snd_hda_get_connections(codec, nid, conn,
2806                                                     ARRAY_SIZE(conn));
2807                         if (n <= 0)
2808                                 break;
2809                         if (n > 1) {
2810                                 spec->mux_nids[i] = nid;
2811                                 break;
2812                         }
2813                         nid = conn[0];
2814                 }
2815         }
2816         return 0;
2817 }
2818
2819 static int patch_vt1708(struct hda_codec *codec)
2820 {
2821         struct via_spec *spec;
2822         int err;
2823
2824         /* create a codec specific record */
2825         spec = via_new_spec(codec);
2826         if (spec == NULL)
2827                 return -ENOMEM;
2828
2829         spec->aa_mix_nid = 0x17;
2830
2831         /* Add HP and CD pin config connect bit re-config action */
2832         vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2833         vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2834
2835         /* automatic parse from the BIOS config */
2836         err = via_parse_auto_config(codec);
2837         if (err < 0) {
2838                 via_free(codec);
2839                 return err;
2840         }
2841
2842         /* add jack detect on/off control */
2843         if (!via_clone_control(spec, &vt1708_jack_detect_ctl))
2844                 return -ENOMEM;
2845
2846         /* disable 32bit format on VT1708 */
2847         if (codec->vendor_id == 0x11061708)
2848                 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2849
2850         spec->init_verbs[spec->num_iverbs++] = vt1708_init_verbs;
2851
2852         codec->patch_ops = via_patch_ops;
2853
2854         INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2855         return 0;
2856 }
2857
2858 static int patch_vt1709(struct hda_codec *codec)
2859 {
2860         struct via_spec *spec;
2861         int err;
2862
2863         /* create a codec specific record */
2864         spec = via_new_spec(codec);
2865         if (spec == NULL)
2866                 return -ENOMEM;
2867
2868         spec->aa_mix_nid = 0x18;
2869
2870         err = via_parse_auto_config(codec);
2871         if (err < 0) {
2872                 via_free(codec);
2873                 return err;
2874         }
2875
2876         codec->patch_ops = via_patch_ops;
2877
2878         return 0;
2879 }
2880
2881 static void set_widgets_power_state_vt1708B(struct hda_codec *codec)
2882 {
2883         struct via_spec *spec = codec->spec;
2884         int imux_is_smixer;
2885         unsigned int parm;
2886         int is_8ch = 0;
2887         if ((spec->codec_type != VT1708B_4CH) &&
2888             (codec->vendor_id != 0x11064397))
2889                 is_8ch = 1;
2890
2891         /* SW0 (17h) = stereo mixer */
2892         imux_is_smixer =
2893         (snd_hda_codec_read(codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
2894          == ((spec->codec_type == VT1708S) ? 5 : 0));
2895         /* inputs */
2896         /* PW 1/2/5 (1ah/1bh/1eh) */
2897         parm = AC_PWRST_D3;
2898         set_pin_power_state(codec, 0x1a, &parm);
2899         set_pin_power_state(codec, 0x1b, &parm);
2900         set_pin_power_state(codec, 0x1e, &parm);
2901         if (imux_is_smixer)
2902                 parm = AC_PWRST_D0;
2903         /* SW0 (17h), AIW 0/1 (13h/14h) */
2904         snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
2905         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
2906         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
2907
2908         /* outputs */
2909         /* PW0 (19h), SW1 (18h), AOW1 (11h) */
2910         parm = AC_PWRST_D3;
2911         set_pin_power_state(codec, 0x19, &parm);
2912         if (spec->smart51_enabled)
2913                 set_pin_power_state(codec, 0x1b, &parm);
2914         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
2915         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
2916
2917         /* PW6 (22h), SW2 (26h), AOW2 (24h) */
2918         if (is_8ch) {
2919                 parm = AC_PWRST_D3;
2920                 set_pin_power_state(codec, 0x22, &parm);
2921                 if (spec->smart51_enabled)
2922                         set_pin_power_state(codec, 0x1a, &parm);
2923                 snd_hda_codec_write(codec, 0x26, 0,
2924                                     AC_VERB_SET_POWER_STATE, parm);
2925                 snd_hda_codec_write(codec, 0x24, 0,
2926                                     AC_VERB_SET_POWER_STATE, parm);
2927         } else if (codec->vendor_id == 0x11064397) {
2928                 /* PW7(23h), SW2(27h), AOW2(25h) */
2929                 parm = AC_PWRST_D3;
2930                 set_pin_power_state(codec, 0x23, &parm);
2931                 if (spec->smart51_enabled)
2932                         set_pin_power_state(codec, 0x1a, &parm);
2933                 snd_hda_codec_write(codec, 0x27, 0,
2934                                     AC_VERB_SET_POWER_STATE, parm);
2935                 snd_hda_codec_write(codec, 0x25, 0,
2936                                     AC_VERB_SET_POWER_STATE, parm);
2937         }
2938
2939         /* PW 3/4/7 (1ch/1dh/23h) */
2940         parm = AC_PWRST_D3;
2941         /* force to D0 for internal Speaker */
2942         set_pin_power_state(codec, 0x1c, &parm);
2943         set_pin_power_state(codec, 0x1d, &parm);
2944         if (is_8ch)
2945                 set_pin_power_state(codec, 0x23, &parm);
2946
2947         /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
2948         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
2949                             imux_is_smixer ? AC_PWRST_D0 : parm);
2950         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
2951         if (is_8ch) {
2952                 snd_hda_codec_write(codec, 0x25, 0,
2953                                     AC_VERB_SET_POWER_STATE, parm);
2954                 snd_hda_codec_write(codec, 0x27, 0,
2955                                     AC_VERB_SET_POWER_STATE, parm);
2956         } else if (codec->vendor_id == 0x11064397 && spec->hp_independent_mode)
2957                 snd_hda_codec_write(codec, 0x25, 0,
2958                                     AC_VERB_SET_POWER_STATE, parm);
2959 }
2960
2961 static int patch_vt1708S(struct hda_codec *codec);
2962 static int patch_vt1708B(struct hda_codec *codec)
2963 {
2964         struct via_spec *spec;
2965         int err;
2966
2967         if (get_codec_type(codec) == VT1708BCE)
2968                 return patch_vt1708S(codec);
2969
2970         /* create a codec specific record */
2971         spec = via_new_spec(codec);
2972         if (spec == NULL)
2973                 return -ENOMEM;
2974
2975         spec->aa_mix_nid = 0x16;
2976
2977         /* automatic parse from the BIOS config */
2978         err = via_parse_auto_config(codec);
2979         if (err < 0) {
2980                 via_free(codec);
2981                 return err;
2982         }
2983
2984         codec->patch_ops = via_patch_ops;
2985
2986         spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;
2987
2988         return 0;
2989 }
2990
2991 /* Patch for VT1708S */
2992 static const struct hda_verb vt1708S_init_verbs[] = {
2993         /* Enable Mic Boost Volume backdoor */
2994         {0x1, 0xf98, 0x1},
2995         /* don't bybass mixer */
2996         {0x1, 0xf88, 0xc0},
2997         { }
2998 };
2999
3000 /* fill out digital output widgets; one for master and one for slave outputs */
3001 static void fill_dig_outs(struct hda_codec *codec)
3002 {
3003         struct via_spec *spec = codec->spec;
3004         int i;
3005
3006         for (i = 0; i < spec->autocfg.dig_outs; i++) {
3007                 hda_nid_t nid;
3008                 int conn;
3009
3010                 nid = spec->autocfg.dig_out_pins[i];
3011                 if (!nid)
3012                         continue;
3013                 conn = snd_hda_get_connections(codec, nid, &nid, 1);
3014                 if (conn < 1)
3015                         continue;
3016                 if (!spec->multiout.dig_out_nid)
3017                         spec->multiout.dig_out_nid = nid;
3018                 else {
3019                         spec->slave_dig_outs[0] = nid;
3020                         break; /* at most two dig outs */
3021                 }
3022         }
3023 }
3024
3025 static void fill_dig_in(struct hda_codec *codec)
3026 {
3027         struct via_spec *spec = codec->spec;
3028         hda_nid_t dig_nid;
3029         int i, err;
3030
3031         if (!spec->autocfg.dig_in_pin)
3032                 return;
3033
3034         dig_nid = codec->start_nid;
3035         for (i = 0; i < codec->num_nodes; i++, dig_nid++) {
3036                 unsigned int wcaps = get_wcaps(codec, dig_nid);
3037                 if (get_wcaps_type(wcaps) != AC_WID_AUD_IN)
3038                         continue;
3039                 if (!(wcaps & AC_WCAP_DIGITAL))
3040                         continue;
3041                 if (!(wcaps & AC_WCAP_CONN_LIST))
3042                         continue;
3043                 err = get_connection_index(codec, dig_nid,
3044                                            spec->autocfg.dig_in_pin);
3045                 if (err >= 0) {
3046                         spec->dig_in_nid = dig_nid;
3047                         break;
3048                 }
3049         }
3050 }
3051
3052 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
3053                                int offset, int num_steps, int step_size)
3054 {
3055         snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
3056                                   (offset << AC_AMPCAP_OFFSET_SHIFT) |
3057                                   (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
3058                                   (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
3059                                   (0 << AC_AMPCAP_MUTE_SHIFT));
3060 }
3061
3062 static int patch_vt1708S(struct hda_codec *codec)
3063 {
3064         struct via_spec *spec;
3065         int err;
3066
3067         /* create a codec specific record */
3068         spec = via_new_spec(codec);
3069         if (spec == NULL)
3070                 return -ENOMEM;
3071
3072         spec->aa_mix_nid = 0x16;
3073         override_mic_boost(codec, 0x1a, 0, 3, 40);
3074         override_mic_boost(codec, 0x1e, 0, 3, 40);
3075
3076         /* automatic parse from the BIOS config */
3077         err = via_parse_auto_config(codec);
3078         if (err < 0) {
3079                 via_free(codec);
3080                 return err;
3081         }
3082
3083         spec->init_verbs[spec->num_iverbs++] = vt1708S_init_verbs;
3084
3085         codec->patch_ops = via_patch_ops;
3086
3087         /* correct names for VT1708BCE */
3088         if (get_codec_type(codec) == VT1708BCE) {
3089                 kfree(codec->chip_name);
3090                 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
3091                 snprintf(codec->bus->card->mixername,
3092                          sizeof(codec->bus->card->mixername),
3093                          "%s %s", codec->vendor_name, codec->chip_name);
3094         }
3095         /* correct names for VT1705 */
3096         if (codec->vendor_id == 0x11064397)     {
3097                 kfree(codec->chip_name);
3098                 codec->chip_name = kstrdup("VT1705", GFP_KERNEL);
3099                 snprintf(codec->bus->card->mixername,
3100                          sizeof(codec->bus->card->mixername),
3101                          "%s %s", codec->vendor_name, codec->chip_name);
3102         }
3103         spec->set_widgets_power_state =  set_widgets_power_state_vt1708B;
3104         return 0;
3105 }
3106
3107 /* Patch for VT1702 */
3108
3109 static const struct hda_verb vt1702_init_verbs[] = {
3110         /* mixer enable */
3111         {0x1, 0xF88, 0x3},
3112         /* GPIO 0~2 */
3113         {0x1, 0xF82, 0x3F},
3114         { }
3115 };
3116
3117 static void set_widgets_power_state_vt1702(struct hda_codec *codec)
3118 {
3119         int imux_is_smixer =
3120         snd_hda_codec_read(codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3121         unsigned int parm;
3122         /* inputs */
3123         /* PW 1/2/5 (14h/15h/18h) */
3124         parm = AC_PWRST_D3;
3125         set_pin_power_state(codec, 0x14, &parm);
3126         set_pin_power_state(codec, 0x15, &parm);
3127         set_pin_power_state(codec, 0x18, &parm);
3128         if (imux_is_smixer)
3129                 parm = AC_PWRST_D0; /* SW0 (13h) = stereo mixer (idx 3) */
3130         /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
3131         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3132         snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE, parm);
3133         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3134         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE, parm);
3135
3136         /* outputs */
3137         /* PW 3/4 (16h/17h) */
3138         parm = AC_PWRST_D3;
3139         set_pin_power_state(codec, 0x17, &parm);
3140         set_pin_power_state(codec, 0x16, &parm);
3141         /* MW0 (1ah), AOW 0/1 (10h/1dh) */
3142         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
3143                             imux_is_smixer ? AC_PWRST_D0 : parm);
3144         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3145         snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3146 }
3147
3148 static int patch_vt1702(struct hda_codec *codec)
3149 {
3150         struct via_spec *spec;
3151         int err;
3152
3153         /* create a codec specific record */
3154         spec = via_new_spec(codec);
3155         if (spec == NULL)
3156                 return -ENOMEM;
3157
3158         spec->aa_mix_nid = 0x1a;
3159
3160         /* limit AA path volume to 0 dB */
3161         snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
3162                                   (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
3163                                   (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
3164                                   (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
3165                                   (1 << AC_AMPCAP_MUTE_SHIFT));
3166
3167         /* automatic parse from the BIOS config */
3168         err = via_parse_auto_config(codec);
3169         if (err < 0) {
3170                 via_free(codec);
3171                 return err;
3172         }
3173
3174         spec->init_verbs[spec->num_iverbs++] = vt1702_init_verbs;
3175
3176         codec->patch_ops = via_patch_ops;
3177
3178         spec->set_widgets_power_state =  set_widgets_power_state_vt1702;
3179         return 0;
3180 }
3181
3182 /* Patch for VT1718S */
3183
3184 static const struct hda_verb vt1718S_init_verbs[] = {
3185         /* Enable MW0 adjust Gain 5 */
3186         {0x1, 0xfb2, 0x10},
3187         /* Enable Boost Volume backdoor */
3188         {0x1, 0xf88, 0x8},
3189
3190         { }
3191 };
3192
3193 static void set_widgets_power_state_vt1718S(struct hda_codec *codec)
3194 {
3195         struct via_spec *spec = codec->spec;
3196         int imux_is_smixer;
3197         unsigned int parm;
3198         /* MUX6 (1eh) = stereo mixer */
3199         imux_is_smixer =
3200         snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
3201         /* inputs */
3202         /* PW 5/6/7 (29h/2ah/2bh) */
3203         parm = AC_PWRST_D3;
3204         set_pin_power_state(codec, 0x29, &parm);
3205         set_pin_power_state(codec, 0x2a, &parm);
3206         set_pin_power_state(codec, 0x2b, &parm);
3207         if (imux_is_smixer)
3208                 parm = AC_PWRST_D0;
3209         /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
3210         snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3211         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3212         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3213         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3214
3215         /* outputs */
3216         /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
3217         parm = AC_PWRST_D3;
3218         set_pin_power_state(codec, 0x27, &parm);
3219         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE, parm);
3220         snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE, parm);
3221
3222         /* PW2 (26h), AOW2 (ah) */
3223         parm = AC_PWRST_D3;
3224         set_pin_power_state(codec, 0x26, &parm);
3225         if (spec->smart51_enabled)
3226                 set_pin_power_state(codec, 0x2b, &parm);
3227         snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE, parm);
3228
3229         /* PW0 (24h), AOW0 (8h) */
3230         parm = AC_PWRST_D3;
3231         set_pin_power_state(codec, 0x24, &parm);
3232         if (!spec->hp_independent_mode) /* check for redirected HP */
3233                 set_pin_power_state(codec, 0x28, &parm);
3234         snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3235         /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
3236         snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
3237                             imux_is_smixer ? AC_PWRST_D0 : parm);
3238
3239         /* PW1 (25h), AOW1 (9h) */
3240         parm = AC_PWRST_D3;
3241         set_pin_power_state(codec, 0x25, &parm);
3242         if (spec->smart51_enabled)
3243                 set_pin_power_state(codec, 0x2a, &parm);
3244         snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE, parm);
3245
3246         if (spec->hp_independent_mode) {
3247                 /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
3248                 parm = AC_PWRST_D3;
3249                 set_pin_power_state(codec, 0x28, &parm);
3250                 snd_hda_codec_write(codec, 0x1b, 0,
3251                                     AC_VERB_SET_POWER_STATE, parm);
3252                 snd_hda_codec_write(codec, 0x34, 0,
3253                                     AC_VERB_SET_POWER_STATE, parm);
3254                 snd_hda_codec_write(codec, 0xc, 0,
3255                                     AC_VERB_SET_POWER_STATE, parm);
3256         }
3257 }
3258
3259 /* Add a connection to the primary DAC from AA-mixer for some codecs
3260  * This isn't listed from the raw info, but the chip has a secret connection.
3261  */
3262 static int add_secret_dac_path(struct hda_codec *codec)
3263 {
3264         struct via_spec *spec = codec->spec;
3265         int i, nums;
3266         hda_nid_t conn[8];
3267         hda_nid_t nid;
3268
3269         if (!spec->aa_mix_nid)
3270                 return 0;
3271         nums = snd_hda_get_connections(codec, spec->aa_mix_nid, conn,
3272                                        ARRAY_SIZE(conn) - 1);
3273         for (i = 0; i < nums; i++) {
3274                 if (get_wcaps_type(get_wcaps(codec, conn[i])) == AC_WID_AUD_OUT)
3275                         return 0;
3276         }
3277
3278         /* find the primary DAC and add to the connection list */
3279         nid = codec->start_nid;
3280         for (i = 0; i < codec->num_nodes; i++, nid++) {
3281                 unsigned int caps = get_wcaps(codec, nid);
3282                 if (get_wcaps_type(caps) == AC_WID_AUD_OUT &&
3283                     !(caps & AC_WCAP_DIGITAL)) {
3284                         conn[nums++] = nid;
3285                         return snd_hda_override_conn_list(codec,
3286                                                           spec->aa_mix_nid,
3287                                                           nums, conn);
3288                 }
3289         }
3290         return 0;
3291 }
3292
3293
3294 static int patch_vt1718S(struct hda_codec *codec)
3295 {
3296         struct via_spec *spec;
3297         int err;
3298
3299         /* create a codec specific record */
3300         spec = via_new_spec(codec);
3301         if (spec == NULL)
3302                 return -ENOMEM;
3303
3304         spec->aa_mix_nid = 0x21;
3305         override_mic_boost(codec, 0x2b, 0, 3, 40);
3306         override_mic_boost(codec, 0x29, 0, 3, 40);
3307         add_secret_dac_path(codec);
3308
3309         /* automatic parse from the BIOS config */
3310         err = via_parse_auto_config(codec);
3311         if (err < 0) {
3312                 via_free(codec);
3313                 return err;
3314         }
3315
3316         spec->init_verbs[spec->num_iverbs++] = vt1718S_init_verbs;
3317
3318         codec->patch_ops = via_patch_ops;
3319
3320         spec->set_widgets_power_state =  set_widgets_power_state_vt1718S;
3321
3322         return 0;
3323 }
3324
3325 /* Patch for VT1716S */
3326
3327 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
3328                             struct snd_ctl_elem_info *uinfo)
3329 {
3330         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
3331         uinfo->count = 1;
3332         uinfo->value.integer.min = 0;
3333         uinfo->value.integer.max = 1;
3334         return 0;
3335 }
3336
3337 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
3338                            struct snd_ctl_elem_value *ucontrol)
3339 {
3340         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3341         int index = 0;
3342
3343         index = snd_hda_codec_read(codec, 0x26, 0,
3344                                                AC_VERB_GET_CONNECT_SEL, 0);
3345         if (index != -1)
3346                 *ucontrol->value.integer.value = index;
3347
3348         return 0;
3349 }
3350
3351 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
3352                            struct snd_ctl_elem_value *ucontrol)
3353 {
3354         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3355         struct via_spec *spec = codec->spec;
3356         int index = *ucontrol->value.integer.value;
3357
3358         snd_hda_codec_write(codec, 0x26, 0,
3359                                                AC_VERB_SET_CONNECT_SEL, index);
3360         spec->dmic_enabled = index;
3361         set_widgets_power_state(codec);
3362         return 1;
3363 }
3364
3365 static const struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
3366         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
3367         {
3368          .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3369          .name = "Digital Mic Capture Switch",
3370          .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
3371          .count = 1,
3372          .info = vt1716s_dmic_info,
3373          .get = vt1716s_dmic_get,
3374          .put = vt1716s_dmic_put,
3375          },
3376         {}                      /* end */
3377 };
3378
3379
3380 /* mono-out mixer elements */
3381 static const struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
3382         HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
3383         { } /* end */
3384 };
3385
3386 static const struct hda_verb vt1716S_init_verbs[] = {
3387         /* Enable Boost Volume backdoor */
3388         {0x1, 0xf8a, 0x80},
3389         /* don't bybass mixer */
3390         {0x1, 0xf88, 0xc0},
3391         /* Enable mono output */
3392         {0x1, 0xf90, 0x08},
3393         { }
3394 };
3395
3396 static void set_widgets_power_state_vt1716S(struct hda_codec *codec)
3397 {
3398         struct via_spec *spec = codec->spec;
3399         int imux_is_smixer;
3400         unsigned int parm;
3401         unsigned int mono_out, present;
3402         /* SW0 (17h) = stereo mixer */
3403         imux_is_smixer =
3404         (snd_hda_codec_read(codec, 0x17, 0,
3405                             AC_VERB_GET_CONNECT_SEL, 0x00) ==  5);
3406         /* inputs */
3407         /* PW 1/2/5 (1ah/1bh/1eh) */
3408         parm = AC_PWRST_D3;
3409         set_pin_power_state(codec, 0x1a, &parm);
3410         set_pin_power_state(codec, 0x1b, &parm);
3411         set_pin_power_state(codec, 0x1e, &parm);
3412         if (imux_is_smixer)
3413                 parm = AC_PWRST_D0;
3414         /* SW0 (17h), AIW0(13h) */
3415         snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE, parm);
3416         snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE, parm);
3417
3418         parm = AC_PWRST_D3;
3419         set_pin_power_state(codec, 0x1e, &parm);
3420         /* PW11 (22h) */
3421         if (spec->dmic_enabled)
3422                 set_pin_power_state(codec, 0x22, &parm);
3423         else
3424                 snd_hda_codec_write(codec, 0x22, 0,
3425                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3426
3427         /* SW2(26h), AIW1(14h) */
3428         snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE, parm);
3429         snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE, parm);
3430
3431         /* outputs */
3432         /* PW0 (19h), SW1 (18h), AOW1 (11h) */
3433         parm = AC_PWRST_D3;
3434         set_pin_power_state(codec, 0x19, &parm);
3435         /* Smart 5.1 PW2(1bh) */
3436         if (spec->smart51_enabled)
3437                 set_pin_power_state(codec, 0x1b, &parm);
3438         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3439         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3440
3441         /* PW7 (23h), SW3 (27h), AOW3 (25h) */
3442         parm = AC_PWRST_D3;
3443         set_pin_power_state(codec, 0x23, &parm);
3444         /* Smart 5.1 PW1(1ah) */
3445         if (spec->smart51_enabled)
3446                 set_pin_power_state(codec, 0x1a, &parm);
3447         snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE, parm);
3448
3449         /* Smart 5.1 PW5(1eh) */
3450         if (spec->smart51_enabled)
3451                 set_pin_power_state(codec, 0x1e, &parm);
3452         snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE, parm);
3453
3454         /* Mono out */
3455         /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
3456         present = snd_hda_jack_detect(codec, 0x1c);
3457
3458         if (present)
3459                 mono_out = 0;
3460         else {
3461                 present = snd_hda_jack_detect(codec, 0x1d);
3462                 if (!spec->hp_independent_mode && present)
3463                         mono_out = 0;
3464                 else
3465                         mono_out = 1;
3466         }
3467         parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
3468         snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE, parm);
3469         snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE, parm);
3470         snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE, parm);
3471
3472         /* PW 3/4 (1ch/1dh) */
3473         parm = AC_PWRST_D3;
3474         set_pin_power_state(codec, 0x1c, &parm);
3475         set_pin_power_state(codec, 0x1d, &parm);
3476         /* HP Independent Mode, power on AOW3 */
3477         if (spec->hp_independent_mode)
3478                 snd_hda_codec_write(codec, 0x25, 0,
3479                                     AC_VERB_SET_POWER_STATE, parm);
3480
3481         /* force to D0 for internal Speaker */
3482         /* MW0 (16h), AOW0 (10h) */
3483         snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
3484                             imux_is_smixer ? AC_PWRST_D0 : parm);
3485         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
3486                             mono_out ? AC_PWRST_D0 : parm);
3487 }
3488
3489 static int patch_vt1716S(struct hda_codec *codec)
3490 {
3491         struct via_spec *spec;
3492         int err;
3493
3494         /* create a codec specific record */
3495         spec = via_new_spec(codec);
3496         if (spec == NULL)
3497                 return -ENOMEM;
3498
3499         spec->aa_mix_nid = 0x16;
3500         override_mic_boost(codec, 0x1a, 0, 3, 40);
3501         override_mic_boost(codec, 0x1e, 0, 3, 40);
3502
3503         /* automatic parse from the BIOS config */
3504         err = via_parse_auto_config(codec);
3505         if (err < 0) {
3506                 via_free(codec);
3507                 return err;
3508         }
3509
3510         spec->init_verbs[spec->num_iverbs++]  = vt1716S_init_verbs;
3511
3512         spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
3513         spec->num_mixers++;
3514
3515         spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
3516
3517         codec->patch_ops = via_patch_ops;
3518
3519         spec->set_widgets_power_state = set_widgets_power_state_vt1716S;
3520         return 0;
3521 }
3522
3523 /* for vt2002P */
3524
3525 static const struct hda_verb vt2002P_init_verbs[] = {
3526         /* Class-D speaker related verbs */
3527         {0x1, 0xfe0, 0x4},
3528         {0x1, 0xfe9, 0x80},
3529         {0x1, 0xfe2, 0x22},
3530         /* Enable Boost Volume backdoor */
3531         {0x1, 0xfb9, 0x24},
3532         /* Enable AOW0 to MW9 */
3533         {0x1, 0xfb8, 0x88},
3534         { }
3535 };
3536
3537 static const struct hda_verb vt1802_init_verbs[] = {
3538         /* Enable Boost Volume backdoor */
3539         {0x1, 0xfb9, 0x24},
3540         /* Enable AOW0 to MW9 */
3541         {0x1, 0xfb8, 0x88},
3542         { }
3543 };
3544
3545 static void set_widgets_power_state_vt2002P(struct hda_codec *codec)
3546 {
3547         struct via_spec *spec = codec->spec;
3548         int imux_is_smixer;
3549         unsigned int parm;
3550         unsigned int present;
3551         /* MUX9 (1eh) = stereo mixer */
3552         imux_is_smixer =
3553         snd_hda_codec_read(codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
3554         /* inputs */
3555         /* PW 5/6/7 (29h/2ah/2bh) */
3556         parm = AC_PWRST_D3;
3557         set_pin_power_state(codec, 0x29, &parm);
3558         set_pin_power_state(codec, 0x2a, &parm);
3559         set_pin_power_state(codec, 0x2b, &parm);
3560         parm = AC_PWRST_D0;
3561         /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
3562         snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3563         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3564         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3565         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3566
3567         /* outputs */
3568         /* AOW0 (8h)*/
3569         snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE, parm);
3570
3571         if (spec->codec_type == VT1802) {
3572                 /* PW4 (28h), MW4 (18h), MUX4(38h) */
3573                 parm = AC_PWRST_D3;
3574                 set_pin_power_state(codec, 0x28, &parm);
3575                 snd_hda_codec_write(codec, 0x18, 0,
3576                                     AC_VERB_SET_POWER_STATE, parm);
3577                 snd_hda_codec_write(codec, 0x38, 0,
3578                                     AC_VERB_SET_POWER_STATE, parm);
3579         } else {
3580                 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
3581                 parm = AC_PWRST_D3;
3582                 set_pin_power_state(codec, 0x26, &parm);
3583                 snd_hda_codec_write(codec, 0x1c, 0,
3584                                     AC_VERB_SET_POWER_STATE, parm);
3585                 snd_hda_codec_write(codec, 0x37, 0,
3586                                     AC_VERB_SET_POWER_STATE, parm);
3587         }
3588
3589         if (spec->codec_type == VT1802) {
3590                 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3591                 parm = AC_PWRST_D3;
3592                 set_pin_power_state(codec, 0x25, &parm);
3593                 snd_hda_codec_write(codec, 0x15, 0,
3594                                     AC_VERB_SET_POWER_STATE, parm);
3595                 snd_hda_codec_write(codec, 0x35, 0,
3596                                     AC_VERB_SET_POWER_STATE, parm);
3597         } else {
3598                 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
3599                 parm = AC_PWRST_D3;
3600                 set_pin_power_state(codec, 0x25, &parm);
3601                 snd_hda_codec_write(codec, 0x19, 0,
3602                                     AC_VERB_SET_POWER_STATE, parm);
3603                 snd_hda_codec_write(codec, 0x35, 0,
3604                                     AC_VERB_SET_POWER_STATE, parm);
3605         }
3606
3607         if (spec->hp_independent_mode)
3608                 snd_hda_codec_write(codec, 0x9, 0,
3609                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3610
3611         /* Class-D */
3612         /* PW0 (24h), MW0(18h/14h), MUX0(34h) */
3613         present = snd_hda_jack_detect(codec, 0x25);
3614
3615         parm = AC_PWRST_D3;
3616         set_pin_power_state(codec, 0x24, &parm);
3617         parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3618         if (spec->codec_type == VT1802)
3619                 snd_hda_codec_write(codec, 0x14, 0,
3620                                     AC_VERB_SET_POWER_STATE, parm);
3621         else
3622                 snd_hda_codec_write(codec, 0x18, 0,
3623                                     AC_VERB_SET_POWER_STATE, parm);
3624         snd_hda_codec_write(codec, 0x34, 0, AC_VERB_SET_POWER_STATE, parm);
3625
3626         /* Mono Out */
3627         present = snd_hda_jack_detect(codec, 0x26);
3628
3629         parm = present ? AC_PWRST_D3 : AC_PWRST_D0;
3630         if (spec->codec_type == VT1802) {
3631                 /* PW15 (33h), MW8(1ch), MUX8(3ch) */
3632                 snd_hda_codec_write(codec, 0x33, 0,
3633                                     AC_VERB_SET_POWER_STATE, parm);
3634                 snd_hda_codec_write(codec, 0x1c, 0,
3635                                     AC_VERB_SET_POWER_STATE, parm);
3636                 snd_hda_codec_write(codec, 0x3c, 0,
3637                                     AC_VERB_SET_POWER_STATE, parm);
3638         } else {
3639                 /* PW15 (31h), MW8(17h), MUX8(3bh) */
3640                 snd_hda_codec_write(codec, 0x31, 0,
3641                                     AC_VERB_SET_POWER_STATE, parm);
3642                 snd_hda_codec_write(codec, 0x17, 0,
3643                                     AC_VERB_SET_POWER_STATE, parm);
3644                 snd_hda_codec_write(codec, 0x3b, 0,
3645                                     AC_VERB_SET_POWER_STATE, parm);
3646         }
3647         /* MW9 (21h) */
3648         if (imux_is_smixer || !is_aa_path_mute(codec))
3649                 snd_hda_codec_write(codec, 0x21, 0,
3650                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3651         else
3652                 snd_hda_codec_write(codec, 0x21, 0,
3653                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3654 }
3655
3656 /* patch for vt2002P */
3657 static int patch_vt2002P(struct hda_codec *codec)
3658 {
3659         struct via_spec *spec;
3660         int err;
3661
3662         /* create a codec specific record */
3663         spec = via_new_spec(codec);
3664         if (spec == NULL)
3665                 return -ENOMEM;
3666
3667         spec->aa_mix_nid = 0x21;
3668         override_mic_boost(codec, 0x2b, 0, 3, 40);
3669         override_mic_boost(codec, 0x29, 0, 3, 40);
3670         add_secret_dac_path(codec);
3671
3672         /* automatic parse from the BIOS config */
3673         err = via_parse_auto_config(codec);
3674         if (err < 0) {
3675                 via_free(codec);
3676                 return err;
3677         }
3678
3679         if (spec->codec_type == VT1802)
3680                 spec->init_verbs[spec->num_iverbs++] = vt1802_init_verbs;
3681         else
3682                 spec->init_verbs[spec->num_iverbs++] = vt2002P_init_verbs;
3683
3684         codec->patch_ops = via_patch_ops;
3685
3686         spec->set_widgets_power_state =  set_widgets_power_state_vt2002P;
3687         return 0;
3688 }
3689
3690 /* for vt1812 */
3691
3692 static const struct hda_verb vt1812_init_verbs[] = {
3693         /* Enable Boost Volume backdoor */
3694         {0x1, 0xfb9, 0x24},
3695         /* Enable AOW0 to MW9 */
3696         {0x1, 0xfb8, 0xa8},
3697         { }
3698 };
3699
3700 static void set_widgets_power_state_vt1812(struct hda_codec *codec)
3701 {
3702         struct via_spec *spec = codec->spec;
3703         unsigned int parm;
3704         unsigned int present;
3705         /* inputs */
3706         /* PW 5/6/7 (29h/2ah/2bh) */
3707         parm = AC_PWRST_D3;
3708         set_pin_power_state(codec, 0x29, &parm);
3709         set_pin_power_state(codec, 0x2a, &parm);
3710         set_pin_power_state(codec, 0x2b, &parm);
3711         parm = AC_PWRST_D0;
3712         /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
3713         snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE, parm);
3714         snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE, parm);
3715         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE, parm);
3716         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE, parm);
3717
3718         /* outputs */
3719         /* AOW0 (8h)*/
3720         snd_hda_codec_write(codec, 0x8, 0,
3721                             AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3722
3723         /* PW4 (28h), MW4 (18h), MUX4(38h) */
3724         parm = AC_PWRST_D3;
3725         set_pin_power_state(codec, 0x28, &parm);
3726         snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE, parm);
3727         snd_hda_codec_write(codec, 0x38, 0, AC_VERB_SET_POWER_STATE, parm);
3728
3729         /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
3730         parm = AC_PWRST_D3;
3731         set_pin_power_state(codec, 0x25, &parm);
3732         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_POWER_STATE, parm);
3733         snd_hda_codec_write(codec, 0x35, 0, AC_VERB_SET_POWER_STATE, parm);
3734         if (spec->hp_independent_mode)
3735                 snd_hda_codec_write(codec, 0x9, 0,
3736                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3737
3738         /* Internal Speaker */
3739         /* PW0 (24h), MW0(14h), MUX0(34h) */
3740         present = snd_hda_jack_detect(codec, 0x25);
3741
3742         parm = AC_PWRST_D3;
3743         set_pin_power_state(codec, 0x24, &parm);
3744         if (present) {
3745                 snd_hda_codec_write(codec, 0x14, 0,
3746                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3747                 snd_hda_codec_write(codec, 0x34, 0,
3748                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3749         } else {
3750                 snd_hda_codec_write(codec, 0x14, 0,
3751                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3752                 snd_hda_codec_write(codec, 0x34, 0,
3753                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3754         }
3755
3756
3757         /* Mono Out */
3758         /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
3759         present = snd_hda_jack_detect(codec, 0x28);
3760
3761         parm = AC_PWRST_D3;
3762         set_pin_power_state(codec, 0x31, &parm);
3763         if (present) {
3764                 snd_hda_codec_write(codec, 0x1c, 0,
3765                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3766                 snd_hda_codec_write(codec, 0x3c, 0,
3767                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3768                 snd_hda_codec_write(codec, 0x3e, 0,
3769                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3770         } else {
3771                 snd_hda_codec_write(codec, 0x1c, 0,
3772                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3773                 snd_hda_codec_write(codec, 0x3c, 0,
3774                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3775                 snd_hda_codec_write(codec, 0x3e, 0,
3776                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
3777         }
3778
3779         /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
3780         parm = AC_PWRST_D3;
3781         set_pin_power_state(codec, 0x33, &parm);
3782         snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE, parm);
3783         snd_hda_codec_write(codec, 0x3d, 0, AC_VERB_SET_POWER_STATE, parm);
3784
3785 }
3786
3787 /* patch for vt1812 */
3788 static int patch_vt1812(struct hda_codec *codec)
3789 {
3790         struct via_spec *spec;
3791         int err;
3792
3793         /* create a codec specific record */
3794         spec = via_new_spec(codec);
3795         if (spec == NULL)
3796                 return -ENOMEM;
3797
3798         spec->aa_mix_nid = 0x21;
3799         override_mic_boost(codec, 0x2b, 0, 3, 40);
3800         override_mic_boost(codec, 0x29, 0, 3, 40);
3801         add_secret_dac_path(codec);
3802
3803         /* automatic parse from the BIOS config */
3804         err = via_parse_auto_config(codec);
3805         if (err < 0) {
3806                 via_free(codec);
3807                 return err;
3808         }
3809
3810         spec->init_verbs[spec->num_iverbs++]  = vt1812_init_verbs;
3811
3812         codec->patch_ops = via_patch_ops;
3813
3814         spec->set_widgets_power_state =  set_widgets_power_state_vt1812;
3815         return 0;
3816 }
3817
3818 /*
3819  * patch entries
3820  */
3821 static const struct hda_codec_preset snd_hda_preset_via[] = {
3822         { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
3823         { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
3824         { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
3825         { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
3826         { .id = 0x1106e710, .name = "VT1709 10-Ch",
3827           .patch = patch_vt1709},
3828         { .id = 0x1106e711, .name = "VT1709 10-Ch",
3829           .patch = patch_vt1709},
3830         { .id = 0x1106e712, .name = "VT1709 10-Ch",
3831           .patch = patch_vt1709},
3832         { .id = 0x1106e713, .name = "VT1709 10-Ch",
3833           .patch = patch_vt1709},
3834         { .id = 0x1106e714, .name = "VT1709 6-Ch",
3835           .patch = patch_vt1709},
3836         { .id = 0x1106e715, .name = "VT1709 6-Ch",
3837           .patch = patch_vt1709},
3838         { .id = 0x1106e716, .name = "VT1709 6-Ch",
3839           .patch = patch_vt1709},
3840         { .id = 0x1106e717, .name = "VT1709 6-Ch",
3841           .patch = patch_vt1709},
3842         { .id = 0x1106e720, .name = "VT1708B 8-Ch",
3843           .patch = patch_vt1708B},
3844         { .id = 0x1106e721, .name = "VT1708B 8-Ch",
3845           .patch = patch_vt1708B},
3846         { .id = 0x1106e722, .name = "VT1708B 8-Ch",
3847           .patch = patch_vt1708B},
3848         { .id = 0x1106e723, .name = "VT1708B 8-Ch",
3849           .patch = patch_vt1708B},
3850         { .id = 0x1106e724, .name = "VT1708B 4-Ch",
3851           .patch = patch_vt1708B},
3852         { .id = 0x1106e725, .name = "VT1708B 4-Ch",
3853           .patch = patch_vt1708B},
3854         { .id = 0x1106e726, .name = "VT1708B 4-Ch",
3855           .patch = patch_vt1708B},
3856         { .id = 0x1106e727, .name = "VT1708B 4-Ch",
3857           .patch = patch_vt1708B},
3858         { .id = 0x11060397, .name = "VT1708S",
3859           .patch = patch_vt1708S},
3860         { .id = 0x11061397, .name = "VT1708S",
3861           .patch = patch_vt1708S},
3862         { .id = 0x11062397, .name = "VT1708S",
3863           .patch = patch_vt1708S},
3864         { .id = 0x11063397, .name = "VT1708S",
3865           .patch = patch_vt1708S},
3866         { .id = 0x11064397, .name = "VT1705",
3867           .patch = patch_vt1708S},
3868         { .id = 0x11065397, .name = "VT1708S",
3869           .patch = patch_vt1708S},
3870         { .id = 0x11066397, .name = "VT1708S",
3871           .patch = patch_vt1708S},
3872         { .id = 0x11067397, .name = "VT1708S",
3873           .patch = patch_vt1708S},
3874         { .id = 0x11060398, .name = "VT1702",
3875           .patch = patch_vt1702},
3876         { .id = 0x11061398, .name = "VT1702",
3877           .patch = patch_vt1702},
3878         { .id = 0x11062398, .name = "VT1702",
3879           .patch = patch_vt1702},
3880         { .id = 0x11063398, .name = "VT1702",
3881           .patch = patch_vt1702},
3882         { .id = 0x11064398, .name = "VT1702",
3883           .patch = patch_vt1702},
3884         { .id = 0x11065398, .name = "VT1702",
3885           .patch = patch_vt1702},
3886         { .id = 0x11066398, .name = "VT1702",
3887           .patch = patch_vt1702},
3888         { .id = 0x11067398, .name = "VT1702",
3889           .patch = patch_vt1702},
3890         { .id = 0x11060428, .name = "VT1718S",
3891           .patch = patch_vt1718S},
3892         { .id = 0x11064428, .name = "VT1718S",
3893           .patch = patch_vt1718S},
3894         { .id = 0x11060441, .name = "VT2020",
3895           .patch = patch_vt1718S},
3896         { .id = 0x11064441, .name = "VT1828S",
3897           .patch = patch_vt1718S},
3898         { .id = 0x11060433, .name = "VT1716S",
3899           .patch = patch_vt1716S},
3900         { .id = 0x1106a721, .name = "VT1716S",
3901           .patch = patch_vt1716S},
3902         { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
3903         { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
3904         { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
3905         { .id = 0x11060440, .name = "VT1818S",
3906           .patch = patch_vt1708S},
3907         { .id = 0x11060446, .name = "VT1802",
3908                 .patch = patch_vt2002P},
3909         { .id = 0x11068446, .name = "VT1802",
3910                 .patch = patch_vt2002P},
3911         {} /* terminator */
3912 };
3913
3914 MODULE_ALIAS("snd-hda-codec-id:1106*");
3915
3916 static struct hda_codec_preset_list via_list = {
3917         .preset = snd_hda_preset_via,
3918         .owner = THIS_MODULE,
3919 };
3920
3921 MODULE_LICENSE("GPL");
3922 MODULE_DESCRIPTION("VIA HD-audio codec");
3923
3924 static int __init patch_via_init(void)
3925 {
3926         return snd_hda_add_codec_preset(&via_list);
3927 }
3928
3929 static void __exit patch_via_exit(void)
3930 {
3931         snd_hda_delete_codec_preset(&via_list);
3932 }
3933
3934 module_init(patch_via_init)
3935 module_exit(patch_via_exit)