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