sound/pci/hda/patch_via.c

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