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