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