SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_via.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for VIA VT17xx/VT18xx/VT20xx codec
   5  *
   6  *  (C) 2006-2009 VIA Technology, Inc.
   7  *  (C) 2006-2008 Takashi Iwai <tiwai@suse.de>
   8  *
   9  *  This driver is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This driver is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22  */
  23
  24 /* * * * * * * * * * * * * * Release History * * * * * * * * * * * * * * * * */
  25 /*                                                                           */
  26 /* 2006-03-03  Lydia Wang  Create the basic patch to support VT1708 codec    */
  27 /* 2006-03-14  Lydia Wang  Modify hard code for some pin widget nid          */
  28 /* 2006-08-02  Lydia Wang  Add support to VT1709 codec                       */
  29 /* 2006-09-08  Lydia Wang  Fix internal loopback recording source select bug */
  30 /* 2007-09-12  Lydia Wang  Add EAPD enable during driver initialization      */
  31 /* 2007-09-17  Lydia Wang  Add VT1708B codec support                        */
  32 /* 2007-11-14  Lydia Wang  Add VT1708A codec HP and CD pin connect config    */
  33 /* 2008-02-03  Lydia Wang  Fix Rear channels and Back channels inverse issue */
  34 /* 2008-03-06  Lydia Wang  Add VT1702 codec and VT1708S codec support        */
  35 /* 2008-04-09  Lydia Wang  Add mute front speaker when HP plugin             */
  36 /* 2008-04-09  Lydia Wang  Add Independent HP feature                        */
  37 /* 2008-05-28  Lydia Wang  Add second S/PDIF Out support for VT1702          */
  38 /* 2008-09-15  Logan Li    Add VT1708S Mic Boost workaround/backdoor         */
  39 /* 2009-02-16  Logan Li    Add support for VT1718S                           */
  40 /* 2009-03-13  Logan Li    Add support for VT1716S                           */
  41 /* 2009-04-14  Lydai Wang  Add support for VT1828S and VT2020                */
  42 /* 2009-07-08  Lydia Wang  Add support for VT2002P                           */
  43 /* 2009-07-21  Lydia Wang  Add support for VT1812                            */
  44 /* 2009-09-19  Lydia Wang  Add support for VT1818S                           */
  45 /*                                                                           */
  46 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  47
  48
  49 #include <linux/init.h>
  50 #include <linux/delay.h>
  51 #include <linux/slab.h>
  52 #include <sound/core.h>
  53 #include <sound/asoundef.h>
  54 #include "hda_codec.h"
  55 #include "hda_local.h"
  56
  57 #define NID_MAPPING             (-1)
  58
  59 /* amp values */
  60 #define AMP_VAL_IDX_SHIFT       19
  61 #define AMP_VAL_IDX_MASK        (0x0f<<19)
  62
  63 /* Pin Widget NID */
  64 #define VT1708_HP_NID           0x13
  65 #define VT1708_DIGOUT_NID       0x14
  66 #define VT1708_DIGIN_NID        0x16
  67 #define VT1708_DIGIN_PIN        0x26
  68 #define VT1708_HP_PIN_NID       0x20
  69 #define VT1708_CD_PIN_NID       0x24
  70
  71 #define VT1709_HP_DAC_NID       0x28
  72 #define VT1709_DIGOUT_NID       0x13
  73 #define VT1709_DIGIN_NID        0x17
  74 #define VT1709_DIGIN_PIN        0x25
  75
  76 #define VT1708B_HP_NID          0x25
  77 #define VT1708B_DIGOUT_NID      0x12
  78 #define VT1708B_DIGIN_NID       0x15
  79 #define VT1708B_DIGIN_PIN       0x21
  80
  81 #define VT1708S_HP_NID          0x25
  82 #define VT1708S_DIGOUT_NID      0x12
  83
  84 #define VT1702_HP_NID           0x17
  85 #define VT1702_DIGOUT_NID       0x11
  86
  87 enum VIA_HDA_CODEC {
  88         UNKNOWN = -1,
  89         VT1708,
  90         VT1709_10CH,
  91         VT1709_6CH,
  92         VT1708B_8CH,
  93         VT1708B_4CH,
  94         VT1708S,
  95         VT1708BCE,
  96         VT1702,
  97         VT1718S,
  98         VT1716S,
  99         VT2002P,
 100         VT1812,
 101         CODEC_TYPES,
 102 };
 103
 104 struct via_spec {
 105         /* codec parameterization */
 106         struct snd_kcontrol_new *mixers[6];
 107         unsigned int num_mixers;
 108
 109         struct hda_verb *init_verbs[5];
 110         unsigned int num_iverbs;
 111
 112         char *stream_name_analog;
 113         struct hda_pcm_stream *stream_analog_playback;
 114         struct hda_pcm_stream *stream_analog_capture;
 115
 116         char *stream_name_digital;
 117         struct hda_pcm_stream *stream_digital_playback;
 118         struct hda_pcm_stream *stream_digital_capture;
 119
 120         /* playback */
 121         struct hda_multi_out multiout;
 122         hda_nid_t slave_dig_outs[2];
 123
 124         /* capture */
 125         unsigned int num_adc_nids;
 126         hda_nid_t *adc_nids;
 127         hda_nid_t mux_nids[3];
 128         hda_nid_t dig_in_nid;
 129         hda_nid_t dig_in_pin;
 130
 131         /* capture source */
 132         const struct hda_input_mux *input_mux;
 133         unsigned int cur_mux[3];
 134
 135         /* PCM information */
 136         struct hda_pcm pcm_rec[3];
 137
 138         /* dynamic controls, init_verbs and input_mux */
 139         struct auto_pin_cfg autocfg;
 140         struct snd_array kctls;
 141         struct hda_input_mux private_imux[2];
 142         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 143
 144         /* HP mode source */
 145         const struct hda_input_mux *hp_mux;
 146         unsigned int hp_independent_mode;
 147         unsigned int hp_independent_mode_index;
 148         unsigned int smart51_enabled;
 149         unsigned int dmic_enabled;
 150         enum VIA_HDA_CODEC codec_type;
 151
 152         /* work to check hp jack state */
 153         struct hda_codec *codec;
 154         struct delayed_work vt1708_hp_work;
 155         int vt1708_jack_detectect;
 156         int vt1708_hp_present;
 157 #ifdef CONFIG_SND_HDA_POWER_SAVE
 158         struct hda_loopback_check loopback;
 159 #endif
 160 };
 161
 162 static struct via_spec * via_new_spec(struct hda_codec *codec)
 163 {
 164         struct via_spec *spec;
 165
 166         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 167         if (spec == NULL)
 168                 return NULL;
 169
 170         codec->spec = spec;
 171         spec->codec = codec;
 172         return spec;
 173 }
 174
 175 static enum VIA_HDA_CODEC get_codec_type(struct hda_codec *codec)
 176 {
 177         u32 vendor_id = codec->vendor_id;
 178         u16 ven_id = vendor_id >> 16;
 179         u16 dev_id = vendor_id & 0xffff;
 180         enum VIA_HDA_CODEC codec_type;
 181
 182         /* get codec type */
 183         if (ven_id != 0x1106)
 184                 codec_type = UNKNOWN;
 185         else if (dev_id >= 0x1708 && dev_id <= 0x170b)
 186                 codec_type = VT1708;
 187         else if (dev_id >= 0xe710 && dev_id <= 0xe713)
 188                 codec_type = VT1709_10CH;
 189         else if (dev_id >= 0xe714 && dev_id <= 0xe717)
 190                 codec_type = VT1709_6CH;
 191         else if (dev_id >= 0xe720 && dev_id <= 0xe723) {
 192                 codec_type = VT1708B_8CH;
 193                 if (snd_hda_param_read(codec, 0x16, AC_PAR_CONNLIST_LEN) == 0x7)
 194                         codec_type = VT1708BCE;
 195         } else if (dev_id >= 0xe724 && dev_id <= 0xe727)
 196                 codec_type = VT1708B_4CH;
 197         else if ((dev_id & 0xfff) == 0x397
 198                  && (dev_id >> 12) < 8)
 199                 codec_type = VT1708S;
 200         else if ((dev_id & 0xfff) == 0x398
 201                  && (dev_id >> 12) < 8)
 202                 codec_type = VT1702;
 203         else if ((dev_id & 0xfff) == 0x428
 204                  && (dev_id >> 12) < 8)
 205                 codec_type = VT1718S;
 206         else if (dev_id == 0x0433 || dev_id == 0xa721)
 207                 codec_type = VT1716S;
 208         else if (dev_id == 0x0441 || dev_id == 0x4441)
 209                 codec_type = VT1718S;
 210         else if (dev_id == 0x0438 || dev_id == 0x4438)
 211                 codec_type = VT2002P;
 212         else if (dev_id == 0x0448)
 213                 codec_type = VT1812;
 214         else if (dev_id == 0x0440)
 215                 codec_type = VT1708S;
 216         else
 217                 codec_type = UNKNOWN;
 218         return codec_type;
 219 };
 220
 221 #define VIA_HP_EVENT            0x01
 222 #define VIA_GPIO_EVENT          0x02
 223 #define VIA_JACK_EVENT          0x04
 224 #define VIA_MONO_EVENT          0x08
 225 #define VIA_SPEAKER_EVENT       0x10
 226 #define VIA_BIND_HP_EVENT       0x20
 227
 228 enum {
 229         VIA_CTL_WIDGET_VOL,
 230         VIA_CTL_WIDGET_MUTE,
 231         VIA_CTL_WIDGET_ANALOG_MUTE,
 232         VIA_CTL_WIDGET_BIND_PIN_MUTE,
 233 };
 234
 235 enum {
 236         AUTO_SEQ_FRONT = 0,
 237         AUTO_SEQ_SURROUND,
 238         AUTO_SEQ_CENLFE,
 239         AUTO_SEQ_SIDE
 240 };
 241
 242 static void analog_low_current_mode(struct hda_codec *codec, int stream_idle);
 243 static void set_jack_power_state(struct hda_codec *codec);
 244 static int is_aa_path_mute(struct hda_codec *codec);
 245
 246 static void vt1708_start_hp_work(struct via_spec *spec)
 247 {
 248         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
 249                 return;
 250         snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
 251                             !spec->vt1708_jack_detectect);
 252         if (!delayed_work_pending(&spec->vt1708_hp_work))
 253                 schedule_delayed_work(&spec->vt1708_hp_work,
 254                                       msecs_to_jiffies(100));
 255 }
 256
 257 static void vt1708_stop_hp_work(struct via_spec *spec)
 258 {
 259         if (spec->codec_type != VT1708 || spec->autocfg.hp_pins[0] == 0)
 260                 return;
 261         if (snd_hda_get_bool_hint(spec->codec, "analog_loopback_hp_detect") == 1
 262             && !is_aa_path_mute(spec->codec))
 263                 return;
 264         snd_hda_codec_write(spec->codec, 0x1, 0, 0xf81,
 265                             !spec->vt1708_jack_detectect);
 266         cancel_delayed_work(&spec->vt1708_hp_work);
 267         flush_scheduled_work();
 268 }
 269
 270
 271 static int analog_input_switch_put(struct snd_kcontrol *kcontrol,
 272                                    struct snd_ctl_elem_value *ucontrol)
 273 {
 274         int change = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
 275         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 276
 277         set_jack_power_state(codec);
 278         analog_low_current_mode(snd_kcontrol_chip(kcontrol), -1);
 279         if (snd_hda_get_bool_hint(codec, "analog_loopback_hp_detect") == 1) {
 280                 if (is_aa_path_mute(codec))
 281                         vt1708_start_hp_work(codec->spec);
 282                 else
 283                         vt1708_stop_hp_work(codec->spec);
 284         }
 285         return change;
 286 }
 287
 288 /* modify .put = snd_hda_mixer_amp_switch_put */
 289 #define ANALOG_INPUT_MUTE                                               \
 290         {               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
 291                         .name = NULL,                                   \
 292                         .index = 0,                                     \
 293                         .info = snd_hda_mixer_amp_switch_info,          \
 294                         .get = snd_hda_mixer_amp_switch_get,            \
 295                         .put = analog_input_switch_put,                 \
 296                         .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
 297
 298 static void via_hp_bind_automute(struct hda_codec *codec);
 299
 300 static int bind_pin_switch_put(struct snd_kcontrol *kcontrol,
 301                                struct snd_ctl_elem_value *ucontrol)
 302 {
 303         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 304         struct via_spec *spec = codec->spec;
 305         int i;
 306         int change = 0;
 307
 308         long *valp = ucontrol->value.integer.value;
 309         int lmute, rmute;
 310         if (strstr(kcontrol->id.name, "Switch") == NULL) {
 311                 snd_printd("Invalid control!\n");
 312                 return change;
 313         }
 314         change = snd_hda_mixer_amp_switch_put(kcontrol,
 315                                               ucontrol);
 316         /* Get mute value */
 317         lmute = *valp ? 0 : HDA_AMP_MUTE;
 318         valp++;
 319         rmute = *valp ? 0 : HDA_AMP_MUTE;
 320
 321         /* Set hp pins */
 322         if (!spec->hp_independent_mode) {
 323                 for (i = 0; i < spec->autocfg.hp_outs; i++) {
 324                         snd_hda_codec_amp_update(
 325                                 codec, spec->autocfg.hp_pins[i],
 326                                 0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
 327                                 lmute);
 328                         snd_hda_codec_amp_update(
 329                                 codec, spec->autocfg.hp_pins[i],
 330                                 1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
 331                                 rmute);
 332                 }
 333         }
 334
 335         if (!lmute && !rmute) {
 336                 /* Line Outs */
 337                 for (i = 0; i < spec->autocfg.line_outs; i++)
 338                         snd_hda_codec_amp_stereo(
 339                                 codec, spec->autocfg.line_out_pins[i],
 340                                 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
 341                 /* Speakers */
 342                 for (i = 0; i < spec->autocfg.speaker_outs; i++)
 343                         snd_hda_codec_amp_stereo(
 344                                 codec, spec->autocfg.speaker_pins[i],
 345                                 HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
 346                 /* unmute */
 347                 via_hp_bind_automute(codec);
 348
 349         } else {
 350                 if (lmute) {
 351                         /* Mute all left channels */
 352                         for (i = 1; i < spec->autocfg.line_outs; i++)
 353                                 snd_hda_codec_amp_update(
 354                                         codec,
 355                                         spec->autocfg.line_out_pins[i],
 356                                         0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
 357                                         lmute);
 358                         for (i = 0; i < spec->autocfg.speaker_outs; i++)
 359                                 snd_hda_codec_amp_update(
 360                                         codec,
 361                                         spec->autocfg.speaker_pins[i],
 362                                         0, HDA_OUTPUT, 0, HDA_AMP_MUTE,
 363                                         lmute);
 364                 }
 365                 if (rmute) {
 366                         /* mute all right channels */
 367                         for (i = 1; i < spec->autocfg.line_outs; i++)
 368                                 snd_hda_codec_amp_update(
 369                                         codec,
 370                                         spec->autocfg.line_out_pins[i],
 371                                         1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
 372                                         rmute);
 373                         for (i = 0; i < spec->autocfg.speaker_outs; i++)
 374                                 snd_hda_codec_amp_update(
 375                                         codec,
 376                                         spec->autocfg.speaker_pins[i],
 377                                         1, HDA_OUTPUT, 0, HDA_AMP_MUTE,
 378                                         rmute);
 379                 }
 380         }
 381         return change;
 382 }
 383
 384 #define BIND_PIN_MUTE                                                   \
 385         {               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
 386                         .name = NULL,                                   \
 387                         .index = 0,                                     \
 388                         .info = snd_hda_mixer_amp_switch_info,          \
 389                         .get = snd_hda_mixer_amp_switch_get,            \
 390                         .put = bind_pin_switch_put,                     \
 391                         .private_value = HDA_COMPOSE_AMP_VAL(0, 3, 0, 0) }
 392
 393 static struct snd_kcontrol_new via_control_templates[] = {
 394         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
 395         HDA_CODEC_MUTE(NULL, 0, 0, 0),
 396         ANALOG_INPUT_MUTE,
 397         BIND_PIN_MUTE,
 398 };
 399
 400 static hda_nid_t vt1708_adc_nids[2] = {
 401         /* ADC1-2 */
 402         0x15, 0x27
 403 };
 404
 405 static hda_nid_t vt1709_adc_nids[3] = {
 406         /* ADC1-2 */
 407         0x14, 0x15, 0x16
 408 };
 409
 410 static hda_nid_t vt1708B_adc_nids[2] = {
 411         /* ADC1-2 */
 412         0x13, 0x14
 413 };
 414
 415 static hda_nid_t vt1708S_adc_nids[2] = {
 416         /* ADC1-2 */
 417         0x13, 0x14
 418 };
 419
 420 static hda_nid_t vt1702_adc_nids[3] = {
 421         /* ADC1-2 */
 422         0x12, 0x20, 0x1F
 423 };
 424
 425 static hda_nid_t vt1718S_adc_nids[2] = {
 426         /* ADC1-2 */
 427         0x10, 0x11
 428 };
 429
 430 static hda_nid_t vt1716S_adc_nids[2] = {
 431         /* ADC1-2 */
 432         0x13, 0x14
 433 };
 434
 435 static hda_nid_t vt2002P_adc_nids[2] = {
 436         /* ADC1-2 */
 437         0x10, 0x11
 438 };
 439
 440 static hda_nid_t vt1812_adc_nids[2] = {
 441         /* ADC1-2 */
 442         0x10, 0x11
 443 };
 444
 445
 446 /* add dynamic controls */
 447 static int via_add_control(struct via_spec *spec, int type, const char *name,
 448                            unsigned long val)
 449 {
 450         struct snd_kcontrol_new *knew;
 451
 452         snd_array_init(&spec->kctls, sizeof(*knew), 32);
 453         knew = snd_array_new(&spec->kctls);
 454         if (!knew)
 455                 return -ENOMEM;
 456         *knew = via_control_templates[type];
 457         knew->name = kstrdup(name, GFP_KERNEL);
 458         if (!knew->name)
 459                 return -ENOMEM;
 460         if (get_amp_nid_(val))
 461                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
 462         knew->private_value = val;
 463         return 0;
 464 }
 465
 466 static struct snd_kcontrol_new *via_clone_control(struct via_spec *spec,
 467                                                 struct snd_kcontrol_new *tmpl)
 468 {
 469         struct snd_kcontrol_new *knew;
 470
 471         snd_array_init(&spec->kctls, sizeof(*knew), 32);
 472         knew = snd_array_new(&spec->kctls);
 473         if (!knew)
 474                 return NULL;
 475         *knew = *tmpl;
 476         knew->name = kstrdup(tmpl->name, GFP_KERNEL);
 477         if (!knew->name)
 478                 return NULL;
 479         return knew;
 480 }
 481
 482 static void via_free_kctls(struct hda_codec *codec)
 483 {
 484         struct via_spec *spec = codec->spec;
 485
 486         if (spec->kctls.list) {
 487                 struct snd_kcontrol_new *kctl = spec->kctls.list;
 488                 int i;
 489                 for (i = 0; i < spec->kctls.used; i++)
 490                         kfree(kctl[i].name);
 491         }
 492         snd_array_free(&spec->kctls);
 493 }
 494
 495 /* create input playback/capture controls for the given pin */
 496 static int via_new_analog_input(struct via_spec *spec, const char *ctlname,
 497                                 int idx, int mix_nid)
 498 {
 499         char name[32];
 500         int err;
 501
 502         sprintf(name, "%s Playback Volume", ctlname);
 503         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
 504                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 505         if (err < 0)
 506                 return err;
 507         sprintf(name, "%s Playback Switch", ctlname);
 508         err = via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name,
 509                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 510         if (err < 0)
 511                 return err;
 512         return 0;
 513 }
 514
 515 static void via_auto_set_output_and_unmute(struct hda_codec *codec,
 516                                            hda_nid_t nid, int pin_type,
 517                                            int dac_idx)
 518 {
 519         /* set as output */
 520         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 521                             pin_type);
 522         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 523                             AMP_OUT_UNMUTE);
 524         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
 525                 snd_hda_codec_write(codec, nid, 0,
 526                                     AC_VERB_SET_EAPD_BTLENABLE, 0x02);
 527 }
 528
 529
 530 static void via_auto_init_multi_out(struct hda_codec *codec)
 531 {
 532         struct via_spec *spec = codec->spec;
 533         int i;
 534
 535         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
 536                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
 537                 if (nid)
 538                         via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
 539         }
 540 }
 541
 542 static void via_auto_init_hp_out(struct hda_codec *codec)
 543 {
 544         struct via_spec *spec = codec->spec;
 545         hda_nid_t pin;
 546         int i;
 547
 548         for (i = 0; i < spec->autocfg.hp_outs; i++) {
 549                 pin = spec->autocfg.hp_pins[i];
 550                 if (pin) /* connect to front */
 551                         via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 552         }
 553 }
 554
 555 static void via_auto_init_analog_input(struct hda_codec *codec)
 556 {
 557         struct via_spec *spec = codec->spec;
 558         int i;
 559
 560         for (i = 0; i < AUTO_PIN_LAST; i++) {
 561                 hda_nid_t nid = spec->autocfg.input_pins[i];
 562
 563                 snd_hda_codec_write(codec, nid, 0,
 564                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 565                                     (i <= AUTO_PIN_FRONT_MIC ?
 566                                      PIN_VREF50 : PIN_IN));
 567
 568         }
 569 }
 570
 571 static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin);
 572
 573 static void set_pin_power_state(struct hda_codec *codec, hda_nid_t nid,
 574                                 unsigned int *affected_parm)
 575 {
 576         unsigned parm;
 577         unsigned def_conf = snd_hda_codec_get_pincfg(codec, nid);
 578         unsigned no_presence = (def_conf & AC_DEFCFG_MISC)
 579                 >> AC_DEFCFG_MISC_SHIFT
 580                 & AC_DEFCFG_MISC_NO_PRESENCE; /* do not support pin sense */
 581         unsigned present = snd_hda_jack_detect(codec, nid);
 582         struct via_spec *spec = codec->spec;
 583         if ((spec->smart51_enabled && is_smart51_pins(spec, nid))
 584             || ((no_presence || present)
 585                 && get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)) {
 586                 *affected_parm = AC_PWRST_D0; /* if it's connected */
 587                 parm = AC_PWRST_D0;
 588         } else
 589                 parm = AC_PWRST_D3;
 590
 591         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_POWER_STATE, parm);
 592 }
 593
 594 static void set_jack_power_state(struct hda_codec *codec)
 595 {
 596         struct via_spec *spec = codec->spec;
 597         int imux_is_smixer;
 598         unsigned int parm;
 599
 600         if (spec->codec_type == VT1702) {
 601                 imux_is_smixer = snd_hda_codec_read(
 602                         codec, 0x13, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
 603                 /* inputs */
 604                 /* PW 1/2/5 (14h/15h/18h) */
 605                 parm = AC_PWRST_D3;
 606                 set_pin_power_state(codec, 0x14, &parm);
 607                 set_pin_power_state(codec, 0x15, &parm);
 608                 set_pin_power_state(codec, 0x18, &parm);
 609                 if (imux_is_smixer)
 610                         parm = AC_PWRST_D0; /* SW0 = stereo mixer (idx 3) */
 611                 /* SW0 (13h), AIW 0/1/2 (12h/1fh/20h) */
 612                 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE,
 613                                     parm);
 614                 snd_hda_codec_write(codec, 0x12, 0, AC_VERB_SET_POWER_STATE,
 615                                     parm);
 616                 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE,
 617                                     parm);
 618                 snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_POWER_STATE,
 619                                     parm);
 620
 621                 /* outputs */
 622                 /* PW 3/4 (16h/17h) */
 623                 parm = AC_PWRST_D3;
 624                 set_pin_power_state(codec, 0x16, &parm);
 625                 set_pin_power_state(codec, 0x17, &parm);
 626                 /* MW0 (1ah), AOW 0/1 (10h/1dh) */
 627                 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
 628                                     imux_is_smixer ? AC_PWRST_D0 : parm);
 629                 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
 630                                     parm);
 631                 snd_hda_codec_write(codec, 0x1d, 0, AC_VERB_SET_POWER_STATE,
 632                                     parm);
 633         } else if (spec->codec_type == VT1708B_8CH
 634                    || spec->codec_type == VT1708B_4CH
 635                    || spec->codec_type == VT1708S) {
 636                 /* SW0 (17h) = stereo mixer */
 637                 int is_8ch = spec->codec_type != VT1708B_4CH;
 638                 imux_is_smixer = snd_hda_codec_read(
 639                         codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00)
 640                         == ((spec->codec_type == VT1708S)  ? 5 : 0);
 641                 /* inputs */
 642                 /* PW 1/2/5 (1ah/1bh/1eh) */
 643                 parm = AC_PWRST_D3;
 644                 set_pin_power_state(codec, 0x1a, &parm);
 645                 set_pin_power_state(codec, 0x1b, &parm);
 646                 set_pin_power_state(codec, 0x1e, &parm);
 647                 if (imux_is_smixer)
 648                         parm = AC_PWRST_D0;
 649                 /* SW0 (17h), AIW 0/1 (13h/14h) */
 650                 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE,
 651                                     parm);
 652                 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE,
 653                                     parm);
 654                 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE,
 655                                     parm);
 656
 657                 /* outputs */
 658                 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
 659                 parm = AC_PWRST_D3;
 660                 set_pin_power_state(codec, 0x19, &parm);
 661                 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE,
 662                                     parm);
 663                 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
 664                                     parm);
 665
 666                 /* PW6 (22h), SW2 (26h), AOW2 (24h) */
 667                 if (is_8ch) {
 668                         parm = AC_PWRST_D3;
 669                         set_pin_power_state(codec, 0x22, &parm);
 670                         snd_hda_codec_write(codec, 0x26, 0,
 671                                             AC_VERB_SET_POWER_STATE, parm);
 672                         snd_hda_codec_write(codec, 0x24, 0,
 673                                             AC_VERB_SET_POWER_STATE, parm);
 674                 }
 675
 676                 /* PW 3/4/7 (1ch/1dh/23h) */
 677                 parm = AC_PWRST_D3;
 678                 /* force to D0 for internal Speaker */
 679                 set_pin_power_state(codec, 0x1c, &parm);
 680                 set_pin_power_state(codec, 0x1d, &parm);
 681                 if (is_8ch)
 682                         set_pin_power_state(codec, 0x23, &parm);
 683                 /* MW0 (16h), Sw3 (27h), AOW 0/3 (10h/25h) */
 684                 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
 685                                     imux_is_smixer ? AC_PWRST_D0 : parm);
 686                 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
 687                                     parm);
 688                 if (is_8ch) {
 689                         snd_hda_codec_write(codec, 0x25, 0,
 690                                             AC_VERB_SET_POWER_STATE, parm);
 691                         snd_hda_codec_write(codec, 0x27, 0,
 692                                             AC_VERB_SET_POWER_STATE, parm);
 693                 }
 694         }  else if (spec->codec_type == VT1718S) {
 695                 /* MUX6 (1eh) = stereo mixer */
 696                 imux_is_smixer = snd_hda_codec_read(
 697                         codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
 698                 /* inputs */
 699                 /* PW 5/6/7 (29h/2ah/2bh) */
 700                 parm = AC_PWRST_D3;
 701                 set_pin_power_state(codec, 0x29, &parm);
 702                 set_pin_power_state(codec, 0x2a, &parm);
 703                 set_pin_power_state(codec, 0x2b, &parm);
 704                 if (imux_is_smixer)
 705                         parm = AC_PWRST_D0;
 706                 /* MUX6/7 (1eh/1fh), AIW 0/1 (10h/11h) */
 707                 snd_hda_codec_write(codec, 0x1e, 0, AC_VERB_SET_POWER_STATE,
 708                                     parm);
 709                 snd_hda_codec_write(codec, 0x1f, 0, AC_VERB_SET_POWER_STATE,
 710                                     parm);
 711                 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
 712                                     parm);
 713                 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
 714                                     parm);
 715
 716                 /* outputs */
 717                 /* PW3 (27h), MW2 (1ah), AOW3 (bh) */
 718                 parm = AC_PWRST_D3;
 719                 set_pin_power_state(codec, 0x27, &parm);
 720                 snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_POWER_STATE,
 721                                     parm);
 722                 snd_hda_codec_write(codec, 0xb, 0, AC_VERB_SET_POWER_STATE,
 723                                     parm);
 724
 725                 /* PW2 (26h), AOW2 (ah) */
 726                 parm = AC_PWRST_D3;
 727                 set_pin_power_state(codec, 0x26, &parm);
 728                 snd_hda_codec_write(codec, 0xa, 0, AC_VERB_SET_POWER_STATE,
 729                                     parm);
 730
 731                 /* PW0/1 (24h/25h) */
 732                 parm = AC_PWRST_D3;
 733                 set_pin_power_state(codec, 0x24, &parm);
 734                 set_pin_power_state(codec, 0x25, &parm);
 735                 if (!spec->hp_independent_mode) /* check for redirected HP */
 736                         set_pin_power_state(codec, 0x28, &parm);
 737                 snd_hda_codec_write(codec, 0x8, 0, AC_VERB_SET_POWER_STATE,
 738                                     parm);
 739                 snd_hda_codec_write(codec, 0x9, 0, AC_VERB_SET_POWER_STATE,
 740                                     parm);
 741                 /* MW9 (21h), Mw2 (1ah), AOW0 (8h) */
 742                 snd_hda_codec_write(codec, 0x21, 0, AC_VERB_SET_POWER_STATE,
 743                                     imux_is_smixer ? AC_PWRST_D0 : parm);
 744                 if (spec->hp_independent_mode) {
 745                         /* PW4 (28h), MW3 (1bh), MUX1(34h), AOW4 (ch) */
 746                         parm = AC_PWRST_D3;
 747                         set_pin_power_state(codec, 0x28, &parm);
 748                         snd_hda_codec_write(codec, 0x1b, 0,
 749                                             AC_VERB_SET_POWER_STATE, parm);
 750                         snd_hda_codec_write(codec, 0x34, 0,
 751                                             AC_VERB_SET_POWER_STATE, parm);
 752                         snd_hda_codec_write(codec, 0xc, 0,
 753                                             AC_VERB_SET_POWER_STATE, parm);
 754                 }
 755         } else if (spec->codec_type == VT1716S) {
 756                 unsigned int mono_out, present;
 757                 /* SW0 (17h) = stereo mixer */
 758                 imux_is_smixer = snd_hda_codec_read(
 759                         codec, 0x17, 0, AC_VERB_GET_CONNECT_SEL, 0x00) ==  5;
 760                 /* inputs */
 761                 /* PW 1/2/5 (1ah/1bh/1eh) */
 762                 parm = AC_PWRST_D3;
 763                 set_pin_power_state(codec, 0x1a, &parm);
 764                 set_pin_power_state(codec, 0x1b, &parm);
 765                 set_pin_power_state(codec, 0x1e, &parm);
 766                 if (imux_is_smixer)
 767                         parm = AC_PWRST_D0;
 768                 /* SW0 (17h), AIW0(13h) */
 769                 snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_POWER_STATE,
 770                                     parm);
 771                 snd_hda_codec_write(codec, 0x13, 0, AC_VERB_SET_POWER_STATE,
 772                                     parm);
 773
 774                 parm = AC_PWRST_D3;
 775                 set_pin_power_state(codec, 0x1e, &parm);
 776                 /* PW11 (22h) */
 777                 if (spec->dmic_enabled)
 778                         set_pin_power_state(codec, 0x22, &parm);
 779                 else
 780                         snd_hda_codec_write(
 781                                 codec, 0x22, 0,
 782                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 783
 784                 /* SW2(26h), AIW1(14h) */
 785                 snd_hda_codec_write(codec, 0x26, 0, AC_VERB_SET_POWER_STATE,
 786                                     parm);
 787                 snd_hda_codec_write(codec, 0x14, 0, AC_VERB_SET_POWER_STATE,
 788                                     parm);
 789
 790                 /* outputs */
 791                 /* PW0 (19h), SW1 (18h), AOW1 (11h) */
 792                 parm = AC_PWRST_D3;
 793                 set_pin_power_state(codec, 0x19, &parm);
 794                 /* Smart 5.1 PW2(1bh) */
 795                 if (spec->smart51_enabled)
 796                         set_pin_power_state(codec, 0x1b, &parm);
 797                 snd_hda_codec_write(codec, 0x18, 0, AC_VERB_SET_POWER_STATE,
 798                                     parm);
 799                 snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_POWER_STATE,
 800                                     parm);
 801
 802                 /* PW7 (23h), SW3 (27h), AOW3 (25h) */
 803                 parm = AC_PWRST_D3;
 804                 set_pin_power_state(codec, 0x23, &parm);
 805                 /* Smart 5.1 PW1(1ah) */
 806                 if (spec->smart51_enabled)
 807                         set_pin_power_state(codec, 0x1a, &parm);
 808                 snd_hda_codec_write(codec, 0x27, 0, AC_VERB_SET_POWER_STATE,
 809                                     parm);
 810
 811                 /* Smart 5.1 PW5(1eh) */
 812                 if (spec->smart51_enabled)
 813                         set_pin_power_state(codec, 0x1e, &parm);
 814                 snd_hda_codec_write(codec, 0x25, 0, AC_VERB_SET_POWER_STATE,
 815                                     parm);
 816
 817                 /* Mono out */
 818                 /* SW4(28h)->MW1(29h)-> PW12 (2ah)*/
 819                 present = snd_hda_jack_detect(codec, 0x1c);
 820                 if (present)
 821                         mono_out = 0;
 822                 else {
 823                         present = snd_hda_jack_detect(codec, 0x1d);
 824                         if (!spec->hp_independent_mode && present)
 825                                 mono_out = 0;
 826                         else
 827                                 mono_out = 1;
 828                 }
 829                 parm = mono_out ? AC_PWRST_D0 : AC_PWRST_D3;
 830                 snd_hda_codec_write(codec, 0x28, 0, AC_VERB_SET_POWER_STATE,
 831                                     parm);
 832                 snd_hda_codec_write(codec, 0x29, 0, AC_VERB_SET_POWER_STATE,
 833                                     parm);
 834                 snd_hda_codec_write(codec, 0x2a, 0, AC_VERB_SET_POWER_STATE,
 835                                     parm);
 836
 837                 /* PW 3/4 (1ch/1dh) */
 838                 parm = AC_PWRST_D3;
 839                 set_pin_power_state(codec, 0x1c, &parm);
 840                 set_pin_power_state(codec, 0x1d, &parm);
 841                 /* HP Independent Mode, power on AOW3 */
 842                 if (spec->hp_independent_mode)
 843                         snd_hda_codec_write(codec, 0x25, 0,
 844                                             AC_VERB_SET_POWER_STATE, parm);
 845
 846                 /* force to D0 for internal Speaker */
 847                 /* MW0 (16h), AOW0 (10h) */
 848                 snd_hda_codec_write(codec, 0x16, 0, AC_VERB_SET_POWER_STATE,
 849                                     imux_is_smixer ? AC_PWRST_D0 : parm);
 850                 snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_POWER_STATE,
 851                                     mono_out ? AC_PWRST_D0 : parm);
 852         } else if (spec->codec_type == VT2002P) {
 853                 unsigned int present;
 854                 /* MUX9 (1eh) = stereo mixer */
 855                 imux_is_smixer = snd_hda_codec_read(
 856                         codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 3;
 857                 /* inputs */
 858                 /* PW 5/6/7 (29h/2ah/2bh) */
 859                 parm = AC_PWRST_D3;
 860                 set_pin_power_state(codec, 0x29, &parm);
 861                 set_pin_power_state(codec, 0x2a, &parm);
 862                 set_pin_power_state(codec, 0x2b, &parm);
 863                 if (imux_is_smixer)
 864                         parm = AC_PWRST_D0;
 865                 /* MUX9/10 (1eh/1fh), AIW 0/1 (10h/11h) */
 866                 snd_hda_codec_write(codec, 0x1e, 0,
 867                                     AC_VERB_SET_POWER_STATE, parm);
 868                 snd_hda_codec_write(codec, 0x1f, 0,
 869                                     AC_VERB_SET_POWER_STATE, parm);
 870                 snd_hda_codec_write(codec, 0x10, 0,
 871                                     AC_VERB_SET_POWER_STATE, parm);
 872                 snd_hda_codec_write(codec, 0x11, 0,
 873                                     AC_VERB_SET_POWER_STATE, parm);
 874
 875                 /* outputs */
 876                 /* AOW0 (8h)*/
 877                 snd_hda_codec_write(codec, 0x8, 0,
 878                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 879
 880                 /* PW4 (26h), MW4 (1ch), MUX4(37h) */
 881                 parm = AC_PWRST_D3;
 882                 set_pin_power_state(codec, 0x26, &parm);
 883                 snd_hda_codec_write(codec, 0x1c, 0,
 884                                     AC_VERB_SET_POWER_STATE, parm);
 885                 snd_hda_codec_write(codec, 0x37,
 886                                     0, AC_VERB_SET_POWER_STATE, parm);
 887
 888                 /* PW1 (25h), MW1 (19h), MUX1(35h), AOW1 (9h) */
 889                 parm = AC_PWRST_D3;
 890                 set_pin_power_state(codec, 0x25, &parm);
 891                 snd_hda_codec_write(codec, 0x19, 0,
 892                                     AC_VERB_SET_POWER_STATE, parm);
 893                 snd_hda_codec_write(codec, 0x35, 0,
 894                                     AC_VERB_SET_POWER_STATE, parm);
 895                 if (spec->hp_independent_mode)  {
 896                         snd_hda_codec_write(codec, 0x9, 0,
 897                                             AC_VERB_SET_POWER_STATE, parm);
 898                 }
 899
 900                 /* Class-D */
 901                 /* PW0 (24h), MW0(18h), MUX0(34h) */
 902                 present = snd_hda_jack_detect(codec, 0x25);
 903                 parm = AC_PWRST_D3;
 904                 set_pin_power_state(codec, 0x24, &parm);
 905                 if (present) {
 906                         snd_hda_codec_write(
 907                                 codec, 0x18, 0,
 908                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 909                         snd_hda_codec_write(
 910                                 codec, 0x34, 0,
 911                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 912                 } else {
 913                         snd_hda_codec_write(
 914                                 codec, 0x18, 0,
 915                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 916                         snd_hda_codec_write(
 917                                 codec, 0x34, 0,
 918                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 919                 }
 920
 921                 /* Mono Out */
 922                 /* PW15 (31h), MW8(17h), MUX8(3bh) */
 923                 present = snd_hda_jack_detect(codec, 0x26);
 924                 parm = AC_PWRST_D3;
 925                 set_pin_power_state(codec, 0x31, &parm);
 926                 if (present) {
 927                         snd_hda_codec_write(
 928                                 codec, 0x17, 0,
 929                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 930                         snd_hda_codec_write(
 931                                 codec, 0x3b, 0,
 932                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 933                 } else {
 934                         snd_hda_codec_write(
 935                                 codec, 0x17, 0,
 936                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 937                         snd_hda_codec_write(
 938                                 codec, 0x3b, 0,
 939                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 940                 }
 941
 942                 /* MW9 (21h) */
 943                 if (imux_is_smixer || !is_aa_path_mute(codec))
 944                         snd_hda_codec_write(
 945                                 codec, 0x21, 0,
 946                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 947                 else
 948                         snd_hda_codec_write(
 949                                 codec, 0x21, 0,
 950                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
 951         } else if (spec->codec_type == VT1812) {
 952                 unsigned int present;
 953                 /* MUX10 (1eh) = stereo mixer */
 954                 imux_is_smixer = snd_hda_codec_read(
 955                         codec, 0x1e, 0, AC_VERB_GET_CONNECT_SEL, 0x00) == 5;
 956                 /* inputs */
 957                 /* PW 5/6/7 (29h/2ah/2bh) */
 958                 parm = AC_PWRST_D3;
 959                 set_pin_power_state(codec, 0x29, &parm);
 960                 set_pin_power_state(codec, 0x2a, &parm);
 961                 set_pin_power_state(codec, 0x2b, &parm);
 962                 if (imux_is_smixer)
 963                         parm = AC_PWRST_D0;
 964                 /* MUX10/11 (1eh/1fh), AIW 0/1 (10h/11h) */
 965                 snd_hda_codec_write(codec, 0x1e, 0,
 966                                     AC_VERB_SET_POWER_STATE, parm);
 967                 snd_hda_codec_write(codec, 0x1f, 0,
 968                                     AC_VERB_SET_POWER_STATE, parm);
 969                 snd_hda_codec_write(codec, 0x10, 0,
 970                                     AC_VERB_SET_POWER_STATE, parm);
 971                 snd_hda_codec_write(codec, 0x11, 0,
 972                                     AC_VERB_SET_POWER_STATE, parm);
 973
 974                 /* outputs */
 975                 /* AOW0 (8h)*/
 976                 snd_hda_codec_write(codec, 0x8, 0,
 977                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
 978
 979                 /* PW4 (28h), MW4 (18h), MUX4(38h) */
 980                 parm = AC_PWRST_D3;
 981                 set_pin_power_state(codec, 0x28, &parm);
 982                 snd_hda_codec_write(codec, 0x18, 0,
 983                                     AC_VERB_SET_POWER_STATE, parm);
 984                 snd_hda_codec_write(codec, 0x38, 0,
 985                                     AC_VERB_SET_POWER_STATE, parm);
 986
 987                 /* PW1 (25h), MW1 (15h), MUX1(35h), AOW1 (9h) */
 988                 parm = AC_PWRST_D3;
 989                 set_pin_power_state(codec, 0x25, &parm);
 990                 snd_hda_codec_write(codec, 0x15, 0,
 991                                     AC_VERB_SET_POWER_STATE, parm);
 992                 snd_hda_codec_write(codec, 0x35, 0,
 993                                     AC_VERB_SET_POWER_STATE, parm);
 994                 if (spec->hp_independent_mode)  {
 995                         snd_hda_codec_write(codec, 0x9, 0,
 996                                             AC_VERB_SET_POWER_STATE, parm);
 997                 }
 998
 999                 /* Internal Speaker */
1000                 /* PW0 (24h), MW0(14h), MUX0(34h) */
1001                 present = snd_hda_jack_detect(codec, 0x25);
1002                 parm = AC_PWRST_D3;
1003                 set_pin_power_state(codec, 0x24, &parm);
1004                 if (present) {
1005                         snd_hda_codec_write(codec, 0x14, 0,
1006                                             AC_VERB_SET_POWER_STATE,
1007                                             AC_PWRST_D3);
1008                         snd_hda_codec_write(codec, 0x34, 0,
1009                                             AC_VERB_SET_POWER_STATE,
1010                                             AC_PWRST_D3);
1011                 } else {
1012                         snd_hda_codec_write(codec, 0x14, 0,
1013                                             AC_VERB_SET_POWER_STATE,
1014                                             AC_PWRST_D0);
1015                         snd_hda_codec_write(codec, 0x34, 0,
1016                                             AC_VERB_SET_POWER_STATE,
1017                                             AC_PWRST_D0);
1018                 }
1019                 /* Mono Out */
1020                 /* PW13 (31h), MW13(1ch), MUX13(3ch), MW14(3eh) */
1021                 present = snd_hda_jack_detect(codec, 0x28);
1022                 parm = AC_PWRST_D3;
1023                 set_pin_power_state(codec, 0x31, &parm);
1024                 if (present) {
1025                         snd_hda_codec_write(codec, 0x1c, 0,
1026                                             AC_VERB_SET_POWER_STATE,
1027                                             AC_PWRST_D3);
1028                         snd_hda_codec_write(codec, 0x3c, 0,
1029                                             AC_VERB_SET_POWER_STATE,
1030                                             AC_PWRST_D3);
1031                         snd_hda_codec_write(codec, 0x3e, 0,
1032                                             AC_VERB_SET_POWER_STATE,
1033                                             AC_PWRST_D3);
1034                 } else {
1035                         snd_hda_codec_write(codec, 0x1c, 0,
1036                                             AC_VERB_SET_POWER_STATE,
1037                                             AC_PWRST_D0);
1038                         snd_hda_codec_write(codec, 0x3c, 0,
1039                                             AC_VERB_SET_POWER_STATE,
1040                                             AC_PWRST_D0);
1041                         snd_hda_codec_write(codec, 0x3e, 0,
1042                                             AC_VERB_SET_POWER_STATE,
1043                                             AC_PWRST_D0);
1044                 }
1045
1046                 /* PW15 (33h), MW15 (1dh), MUX15(3dh) */
1047                 parm = AC_PWRST_D3;
1048                 set_pin_power_state(codec, 0x33, &parm);
1049                 snd_hda_codec_write(codec, 0x1d, 0,
1050                                     AC_VERB_SET_POWER_STATE, parm);
1051                 snd_hda_codec_write(codec, 0x3d, 0,
1052                                     AC_VERB_SET_POWER_STATE, parm);
1053
1054                 /* MW9 (21h) */
1055                 if (imux_is_smixer || !is_aa_path_mute(codec))
1056                         snd_hda_codec_write(
1057                                 codec, 0x21, 0,
1058                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
1059                 else
1060                         snd_hda_codec_write(
1061                                 codec, 0x21, 0,
1062                                 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
1063         }
1064 }
1065
1066 /*
1067  * input MUX handling
1068  */
1069 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
1070                              struct snd_ctl_elem_info *uinfo)
1071 {
1072         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1073         struct via_spec *spec = codec->spec;
1074         return snd_hda_input_mux_info(spec->input_mux, uinfo);
1075 }
1076
1077 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
1078                             struct snd_ctl_elem_value *ucontrol)
1079 {
1080         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1081         struct via_spec *spec = codec->spec;
1082         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1083
1084         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
1085         return 0;
1086 }
1087
1088 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
1089                             struct snd_ctl_elem_value *ucontrol)
1090 {
1091         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1092         struct via_spec *spec = codec->spec;
1093         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1094
1095         if (!spec->mux_nids[adc_idx])
1096                 return -EINVAL;
1097         /* switch to D0 beofre change index */
1098         if (snd_hda_codec_read(codec, spec->mux_nids[adc_idx], 0,
1099                                AC_VERB_GET_POWER_STATE, 0x00) != AC_PWRST_D0)
1100                 snd_hda_codec_write(codec, spec->mux_nids[adc_idx], 0,
1101                                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
1102         /* update jack power state */
1103         set_jack_power_state(codec);
1104
1105         return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
1106                                      spec->mux_nids[adc_idx],
1107                                      &spec->cur_mux[adc_idx]);
1108 }
1109
1110 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
1111                                    struct snd_ctl_elem_info *uinfo)
1112 {
1113         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1114         struct via_spec *spec = codec->spec;
1115         return snd_hda_input_mux_info(spec->hp_mux, uinfo);
1116 }
1117
1118 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
1119                                   struct snd_ctl_elem_value *ucontrol)
1120 {
1121         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1122         hda_nid_t nid = kcontrol->private_value;
1123         unsigned int pinsel;
1124
1125         /* use !! to translate conn sel 2 for VT1718S */
1126         pinsel = !!snd_hda_codec_read(codec, nid, 0,
1127                                       AC_VERB_GET_CONNECT_SEL,
1128                                       0x00);
1129         ucontrol->value.enumerated.item[0] = pinsel;
1130
1131         return 0;
1132 }
1133
1134 static void activate_ctl(struct hda_codec *codec, const char *name, int active)
1135 {
1136         struct snd_kcontrol *ctl = snd_hda_find_mixer_ctl(codec, name);
1137         if (ctl) {
1138                 ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1139                 ctl->vd[0].access |= active
1140                         ? 0 : SNDRV_CTL_ELEM_ACCESS_INACTIVE;
1141                 snd_ctl_notify(codec->bus->card,
1142                                SNDRV_CTL_EVENT_MASK_VALUE, &ctl->id);
1143         }
1144 }
1145
1146 static hda_nid_t side_mute_channel(struct via_spec *spec)
1147 {
1148         switch (spec->codec_type) {
1149         case VT1708:            return 0x1b;
1150         case VT1709_10CH:       return 0x29;
1151         case VT1708B_8CH:       /* fall thru */
1152         case VT1708S:           return 0x27;
1153         default:                return 0;
1154         }
1155 }
1156
1157 static int update_side_mute_status(struct hda_codec *codec)
1158 {
1159         /* mute side channel */
1160         struct via_spec *spec = codec->spec;
1161         unsigned int parm = spec->hp_independent_mode
1162                 ? AMP_OUT_MUTE : AMP_OUT_UNMUTE;
1163         hda_nid_t sw3 = side_mute_channel(spec);
1164
1165         if (sw3)
1166                 snd_hda_codec_write(codec, sw3, 0, AC_VERB_SET_AMP_GAIN_MUTE,
1167                                     parm);
1168         return 0;
1169 }
1170
1171 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
1172                                   struct snd_ctl_elem_value *ucontrol)
1173 {
1174         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1175         struct via_spec *spec = codec->spec;
1176         hda_nid_t nid = kcontrol->private_value;
1177         unsigned int pinsel = ucontrol->value.enumerated.item[0];
1178         /* Get Independent Mode index of headphone pin widget */
1179         spec->hp_independent_mode = spec->hp_independent_mode_index == pinsel
1180                 ? 1 : 0;
1181         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, pinsel);
1182
1183         if (spec->multiout.hp_nid && spec->multiout.hp_nid
1184             != spec->multiout.dac_nids[HDA_FRONT])
1185                 snd_hda_codec_setup_stream(codec, spec->multiout.hp_nid,
1186                                            0, 0, 0);
1187
1188         update_side_mute_status(codec);
1189         /* update HP volume/swtich active state */
1190         if (spec->codec_type == VT1708S
1191             || spec->codec_type == VT1702
1192             || spec->codec_type == VT1718S
1193             || spec->codec_type == VT1716S
1194             || spec->codec_type == VT2002P
1195             || spec->codec_type == VT1812) {
1196                 activate_ctl(codec, "Headphone Playback Volume",
1197                              spec->hp_independent_mode);
1198                 activate_ctl(codec, "Headphone Playback Switch",
1199                              spec->hp_independent_mode);
1200         }
1201         return 0;
1202 }
1203
1204 static struct snd_kcontrol_new via_hp_mixer[2] = {
1205         {
1206                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1207                 .name = "Independent HP",
1208                 .info = via_independent_hp_info,
1209                 .get = via_independent_hp_get,
1210                 .put = via_independent_hp_put,
1211         },
1212         {
1213                 .iface = NID_MAPPING,
1214                 .name = "Independent HP",
1215         },
1216 };
1217
1218 static int via_hp_build(struct hda_codec *codec)
1219 {
1220         struct via_spec *spec = codec->spec;
1221         struct snd_kcontrol_new *knew;
1222         hda_nid_t nid;
1223         int nums;
1224         hda_nid_t conn[HDA_MAX_CONNECTIONS];
1225
1226         switch (spec->codec_type) {
1227         case VT1718S:
1228                 nid = 0x34;
1229                 break;
1230         case VT2002P:
1231                 nid = 0x35;
1232                 break;
1233         case VT1812:
1234                 nid = 0x3d;
1235                 break;
1236         default:
1237                 nid = spec->autocfg.hp_pins[0];
1238                 break;
1239         }
1240
1241         nums = snd_hda_get_connections(codec, nid, conn, HDA_MAX_CONNECTIONS);
1242         if (nums <= 1)
1243                 return 0;
1244
1245         knew = via_clone_control(spec, &via_hp_mixer[0]);
1246         if (knew == NULL)
1247                 return -ENOMEM;
1248
1249         knew->subdevice = HDA_SUBDEV_NID_FLAG | nid;
1250         knew->private_value = nid;
1251
1252         knew = via_clone_control(spec, &via_hp_mixer[1]);
1253         if (knew == NULL)
1254                 return -ENOMEM;
1255         knew->subdevice = side_mute_channel(spec);
1256
1257         return 0;
1258 }
1259
1260 static void notify_aa_path_ctls(struct hda_codec *codec)
1261 {
1262         int i;
1263         struct snd_ctl_elem_id id;
1264         const char *labels[] = {"Mic", "Front Mic", "Line"};
1265
1266         memset(&id, 0, sizeof(id));
1267         id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1268         for (i = 0; i < ARRAY_SIZE(labels); i++) {
1269                 sprintf(id.name, "%s Playback Volume", labels[i]);
1270                 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
1271                                &id);
1272         }
1273 }
1274
1275 static void mute_aa_path(struct hda_codec *codec, int mute)
1276 {
1277         struct via_spec *spec = codec->spec;
1278         hda_nid_t  nid_mixer;
1279         int start_idx;
1280         int end_idx;
1281         int i;
1282         /* get nid of MW0 and start & end index */
1283         switch (spec->codec_type) {
1284         case VT1708:
1285                 nid_mixer = 0x17;
1286                 start_idx = 2;
1287                 end_idx = 4;
1288                 break;
1289         case VT1709_10CH:
1290         case VT1709_6CH:
1291                 nid_mixer = 0x18;
1292                 start_idx = 2;
1293                 end_idx = 4;
1294                 break;
1295         case VT1708B_8CH:
1296         case VT1708B_4CH:
1297         case VT1708S:
1298         case VT1716S:
1299                 nid_mixer = 0x16;
1300                 start_idx = 2;
1301                 end_idx = 4;
1302                 break;
1303         default:
1304                 return;
1305         }
1306         /* check AA path's mute status */
1307         for (i = start_idx; i <= end_idx; i++) {
1308                 int val = mute ? HDA_AMP_MUTE : HDA_AMP_UNMUTE;
1309                 snd_hda_codec_amp_stereo(codec, nid_mixer, HDA_INPUT, i,
1310                                          HDA_AMP_MUTE, val);
1311         }
1312 }
1313 static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin)
1314 {
1315         int res = 0;
1316         int index;
1317         for (index = AUTO_PIN_MIC; index < AUTO_PIN_FRONT_LINE; index++) {
1318                 if (pin == spec->autocfg.input_pins[index]) {
1319                         res = 1;
1320                         break;
1321                 }
1322         }
1323         return res;
1324 }
1325
1326 static int via_smart51_info(struct snd_kcontrol *kcontrol,
1327                             struct snd_ctl_elem_info *uinfo)
1328 {
1329         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1330         uinfo->count = 1;
1331         uinfo->value.integer.min = 0;
1332         uinfo->value.integer.max = 1;
1333         return 0;
1334 }
1335
1336 static int via_smart51_get(struct snd_kcontrol *kcontrol,
1337                            struct snd_ctl_elem_value *ucontrol)
1338 {
1339         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1340         struct via_spec *spec = codec->spec;
1341         int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE };
1342         int on = 1;
1343         int i;
1344
1345         for (i = 0; i < ARRAY_SIZE(index); i++) {
1346                 hda_nid_t nid = spec->autocfg.input_pins[index[i]];
1347                 if (nid) {
1348                         int ctl =
1349                             snd_hda_codec_read(codec, nid, 0,
1350                                                AC_VERB_GET_PIN_WIDGET_CONTROL,
1351                                                0);
1352                         if (i == AUTO_PIN_FRONT_MIC
1353                             && spec->hp_independent_mode
1354                             && spec->codec_type != VT1718S)
1355                                 continue; /* ignore FMic for independent HP */
1356                         if (ctl & AC_PINCTL_IN_EN
1357                             && !(ctl & AC_PINCTL_OUT_EN))
1358                                 on = 0;
1359                 }
1360         }
1361         *ucontrol->value.integer.value = on;
1362         return 0;
1363 }
1364
1365 static int via_smart51_put(struct snd_kcontrol *kcontrol,
1366                            struct snd_ctl_elem_value *ucontrol)
1367 {
1368         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1369         struct via_spec *spec = codec->spec;
1370         int out_in = *ucontrol->value.integer.value
1371                 ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN;
1372         int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE };
1373         int i;
1374
1375         for (i = 0; i < ARRAY_SIZE(index); i++) {
1376                 hda_nid_t nid = spec->autocfg.input_pins[index[i]];
1377                 if (i == AUTO_PIN_FRONT_MIC
1378                     && spec->hp_independent_mode
1379                     && spec->codec_type != VT1718S)
1380                         continue; /* don't retask FMic for independent HP */
1381                 if (nid) {
1382                         unsigned int parm = snd_hda_codec_read(
1383                                 codec, nid, 0,
1384                                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
1385                         parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
1386                         parm |= out_in;
1387                         snd_hda_codec_write(codec, nid, 0,
1388                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1389                                             parm);
1390                         if (out_in == AC_PINCTL_OUT_EN) {
1391                                 mute_aa_path(codec, 1);
1392                                 notify_aa_path_ctls(codec);
1393                         }
1394                         if (spec->codec_type == VT1718S)
1395                                 snd_hda_codec_amp_stereo(
1396                                         codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE,
1397                                         HDA_AMP_UNMUTE);
1398                 }
1399                 if (i == AUTO_PIN_FRONT_MIC) {
1400                         if (spec->codec_type == VT1708S
1401                             || spec->codec_type == VT1716S) {
1402                                 /* input = index 1 (AOW3) */
1403                                 snd_hda_codec_write(
1404                                         codec, nid, 0,
1405                                         AC_VERB_SET_CONNECT_SEL, 1);
1406                                 snd_hda_codec_amp_stereo(
1407                                         codec, nid, HDA_OUTPUT,
1408                                         0, HDA_AMP_MUTE, HDA_AMP_UNMUTE);
1409                         }
1410                 }
1411         }
1412         spec->smart51_enabled = *ucontrol->value.integer.value;
1413         set_jack_power_state(codec);
1414         return 1;
1415 }
1416
1417 static struct snd_kcontrol_new via_smart51_mixer[2] = {
1418         {
1419          .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1420          .name = "Smart 5.1",
1421          .count = 1,
1422          .info = via_smart51_info,
1423          .get = via_smart51_get,
1424          .put = via_smart51_put,
1425          },
1426         {
1427          .iface = NID_MAPPING,
1428          .name = "Smart 5.1",
1429         }
1430 };
1431
1432 static int via_smart51_build(struct via_spec *spec)
1433 {
1434         struct snd_kcontrol_new *knew;
1435         int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE };
1436         hda_nid_t nid;
1437         int i;
1438
1439         knew = via_clone_control(spec, &via_smart51_mixer[0]);
1440         if (knew == NULL)
1441                 return -ENOMEM;
1442
1443         for (i = 0; i < ARRAY_SIZE(index); i++) {
1444                 nid = spec->autocfg.input_pins[index[i]];
1445                 if (nid) {
1446                         knew = via_clone_control(spec, &via_smart51_mixer[1]);
1447                         if (knew == NULL)
1448                                 return -ENOMEM;
1449                         knew->subdevice = nid;
1450                 }
1451         }
1452
1453         return 0;
1454 }
1455
1456 /* capture mixer elements */
1457 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
1458         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
1459         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
1460         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
1461         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
1462         {
1463                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1464                 /* The multiple "Capture Source" controls confuse alsamixer
1465                  * So call somewhat different..
1466                  */
1467                 /* .name = "Capture Source", */
1468                 .name = "Input Source",
1469                 .count = 1,
1470                 .info = via_mux_enum_info,
1471                 .get = via_mux_enum_get,
1472                 .put = via_mux_enum_put,
1473         },
1474         { } /* end */
1475 };
1476
1477 /* check AA path's mute statue */
1478 static int is_aa_path_mute(struct hda_codec *codec)
1479 {
1480         int mute = 1;
1481         hda_nid_t  nid_mixer;
1482         int start_idx;
1483         int end_idx;
1484         int i;
1485         struct via_spec *spec = codec->spec;
1486         /* get nid of MW0 and start & end index */
1487         switch (spec->codec_type) {
1488         case VT1708B_8CH:
1489         case VT1708B_4CH:
1490         case VT1708S:
1491         case VT1716S:
1492                 nid_mixer = 0x16;
1493                 start_idx = 2;
1494                 end_idx = 4;
1495                 break;
1496         case VT1702:
1497                 nid_mixer = 0x1a;
1498                 start_idx = 1;
1499                 end_idx = 3;
1500                 break;
1501         case VT1718S:
1502                 nid_mixer = 0x21;
1503                 start_idx = 1;
1504                 end_idx = 3;
1505                 break;
1506         case VT2002P:
1507         case VT1812:
1508                 nid_mixer = 0x21;
1509                 start_idx = 0;
1510                 end_idx = 2;
1511                 break;
1512         default:
1513                 return 0;
1514         }
1515         /* check AA path's mute status */
1516         for (i = start_idx; i <= end_idx; i++) {
1517                 unsigned int con_list = snd_hda_codec_read(
1518                         codec, nid_mixer, 0, AC_VERB_GET_CONNECT_LIST, i/4*4);
1519                 int shift = 8 * (i % 4);
1520                 hda_nid_t nid_pin = (con_list & (0xff << shift)) >> shift;
1521                 unsigned int defconf = snd_hda_codec_get_pincfg(codec, nid_pin);
1522                 if (get_defcfg_connect(defconf) == AC_JACK_PORT_COMPLEX) {
1523                         /* check mute status while the pin is connected */
1524                         int mute_l = snd_hda_codec_amp_read(codec, nid_mixer, 0,
1525                                                             HDA_INPUT, i) >> 7;
1526                         int mute_r = snd_hda_codec_amp_read(codec, nid_mixer, 1,
1527                                                             HDA_INPUT, i) >> 7;
1528                         if (!mute_l || !mute_r) {
1529                                 mute = 0;
1530                                 break;
1531                         }
1532                 }
1533         }
1534         return mute;
1535 }
1536
1537 /* enter/exit analog low-current mode */
1538 static void analog_low_current_mode(struct hda_codec *codec, int stream_idle)
1539 {
1540         struct via_spec *spec = codec->spec;
1541         static int saved_stream_idle = 1; /* saved stream idle status */
1542         int enable = is_aa_path_mute(codec);
1543         unsigned int verb = 0;
1544         unsigned int parm = 0;
1545
1546         if (stream_idle == -1)  /* stream status did not change */
1547                 enable = enable && saved_stream_idle;
1548         else {
1549                 enable = enable && stream_idle;
1550                 saved_stream_idle = stream_idle;
1551         }
1552
1553         /* decide low current mode's verb & parameter */
1554         switch (spec->codec_type) {
1555         case VT1708B_8CH:
1556         case VT1708B_4CH:
1557                 verb = 0xf70;
1558                 parm = enable ? 0x02 : 0x00; /* 0x02: 2/3x, 0x00: 1x */
1559                 break;
1560         case VT1708S:
1561         case VT1718S:
1562         case VT1716S:
1563                 verb = 0xf73;
1564                 parm = enable ? 0x51 : 0xe1; /* 0x51: 4/28x, 0xe1: 1x */
1565                 break;
1566         case VT1702:
1567                 verb = 0xf73;
1568                 parm = enable ? 0x01 : 0x1d; /* 0x01: 4/40x, 0x1d: 1x */
1569                 break;
1570         case VT2002P:
1571         case VT1812:
1572                 verb = 0xf93;
1573                 parm = enable ? 0x00 : 0xe0; /* 0x00: 4/40x, 0xe0: 1x */
1574                 break;
1575         default:
1576                 return;         /* other codecs are not supported */
1577         }
1578         /* send verb */
1579         snd_hda_codec_write(codec, codec->afg, 0, verb, parm);
1580 }
1581
1582 /*
1583  * generic initialization of ADC, input mixers and output mixers
1584  */
1585 static struct hda_verb vt1708_volume_init_verbs[] = {
1586         /*
1587          * Unmute ADC0-1 and set the default input to mic-in
1588          */
1589         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1590         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1591
1592
1593         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1594          * mixer widget
1595          */
1596         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1597         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1598         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1599         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1600         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1601         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1602
1603         /*
1604          * Set up output mixers (0x19 - 0x1b)
1605          */
1606         /* set vol=0 to output mixers */
1607         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1608         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1609         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1610
1611         /* Setup default input MW0 to PW4 */
1612         {0x20, AC_VERB_SET_CONNECT_SEL, 0},
1613         /* PW9 Output enable */
1614         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1615         { }
1616 };
1617
1618 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
1619                                  struct hda_codec *codec,
1620                                  struct snd_pcm_substream *substream)
1621 {
1622         struct via_spec *spec = codec->spec;
1623         int idle = substream->pstr->substream_opened == 1
1624                 && substream->ref_count == 0;
1625         analog_low_current_mode(codec, idle);
1626         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
1627                                              hinfo);
1628 }
1629
1630 static void playback_multi_pcm_prep_0(struct hda_codec *codec,
1631                                       unsigned int stream_tag,
1632                                       unsigned int format,
1633                                       struct snd_pcm_substream *substream)
1634 {
1635         struct via_spec *spec = codec->spec;
1636         struct hda_multi_out *mout = &spec->multiout;
1637         hda_nid_t *nids = mout->dac_nids;
1638         int chs = substream->runtime->channels;
1639         int i;
1640
1641         mutex_lock(&codec->spdif_mutex);
1642         if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
1643                 if (chs == 2 &&
1644                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
1645                                                 format) &&
1646                     !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
1647                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
1648                         /* turn off SPDIF once; otherwise the IEC958 bits won't
1649                          * be updated */
1650                         if (codec->spdif_ctls & AC_DIG1_ENABLE)
1651                                 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
1652                                                     AC_VERB_SET_DIGI_CONVERT_1,
1653                                                     codec->spdif_ctls &
1654                                                         ~AC_DIG1_ENABLE & 0xff);
1655                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
1656                                                    stream_tag, 0, format);
1657                         /* turn on again (if needed) */
1658                         if (codec->spdif_ctls & AC_DIG1_ENABLE)
1659                                 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
1660                                                     AC_VERB_SET_DIGI_CONVERT_1,
1661                                                     codec->spdif_ctls & 0xff);
1662                 } else {
1663                         mout->dig_out_used = 0;
1664                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
1665                                                    0, 0, 0);
1666                 }
1667         }
1668         mutex_unlock(&codec->spdif_mutex);
1669
1670         /* front */
1671         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
1672                                    0, format);
1673
1674         if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT]
1675             && !spec->hp_independent_mode)
1676                 /* headphone out will just decode front left/right (stereo) */
1677                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
1678                                            0, format);
1679
1680         /* extra outputs copied from front */
1681         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
1682                 if (mout->extra_out_nid[i])
1683                         snd_hda_codec_setup_stream(codec,
1684                                                    mout->extra_out_nid[i],
1685                                                    stream_tag, 0, format);
1686
1687         /* surrounds */
1688         for (i = 1; i < mout->num_dacs; i++) {
1689                 if (chs >= (i + 1) * 2) /* independent out */
1690                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
1691                                                    i * 2, format);
1692                 else /* copy front */
1693                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
1694                                                    0, format);
1695         }
1696 }
1697
1698 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
1699                                           struct hda_codec *codec,
1700                                           unsigned int stream_tag,
1701                                           unsigned int format,
1702                                           struct snd_pcm_substream *substream)
1703 {
1704         struct via_spec *spec = codec->spec;
1705         struct hda_multi_out *mout = &spec->multiout;
1706         hda_nid_t *nids = mout->dac_nids;
1707
1708         if (substream->number == 0)
1709                 playback_multi_pcm_prep_0(codec, stream_tag, format,
1710                                           substream);
1711         else {
1712                 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
1713                     spec->hp_independent_mode)
1714                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
1715                                                    stream_tag, 0, format);
1716         }
1717         vt1708_start_hp_work(spec);
1718         return 0;
1719 }
1720
1721 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
1722                                     struct hda_codec *codec,
1723                                     struct snd_pcm_substream *substream)
1724 {
1725         struct via_spec *spec = codec->spec;
1726         struct hda_multi_out *mout = &spec->multiout;
1727         hda_nid_t *nids = mout->dac_nids;
1728         int i;
1729
1730         if (substream->number == 0) {
1731                 for (i = 0; i < mout->num_dacs; i++)
1732                         snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0);
1733
1734                 if (mout->hp_nid && !spec->hp_independent_mode)
1735                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
1736                                                    0, 0, 0);
1737
1738                 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
1739                         if (mout->extra_out_nid[i])
1740                                 snd_hda_codec_setup_stream(codec,
1741                                                         mout->extra_out_nid[i],
1742                                                         0, 0, 0);
1743                 mutex_lock(&codec->spdif_mutex);
1744                 if (mout->dig_out_nid &&
1745                     mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
1746                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
1747                                                    0, 0, 0);
1748                         mout->dig_out_used = 0;
1749                 }
1750                 mutex_unlock(&codec->spdif_mutex);
1751         } else {
1752                 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
1753                     spec->hp_independent_mode)
1754                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
1755                                                    0, 0, 0);
1756         }
1757         vt1708_stop_hp_work(spec);
1758         return 0;
1759 }
1760
1761 /*
1762  * Digital out
1763  */
1764 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
1765                                      struct hda_codec *codec,
1766                                      struct snd_pcm_substream *substream)
1767 {
1768         struct via_spec *spec = codec->spec;
1769         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
1770 }
1771
1772 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
1773                                       struct hda_codec *codec,
1774                                       struct snd_pcm_substream *substream)
1775 {
1776         struct via_spec *spec = codec->spec;
1777         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
1778 }
1779
1780 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
1781                                         struct hda_codec *codec,
1782                                         unsigned int stream_tag,
1783                                         unsigned int format,
1784                                         struct snd_pcm_substream *substream)
1785 {
1786         struct via_spec *spec = codec->spec;
1787         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
1788                                              stream_tag, format, substream);
1789 }
1790
1791 static int via_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
1792                                         struct hda_codec *codec,
1793                                         struct snd_pcm_substream *substream)
1794 {
1795         struct via_spec *spec = codec->spec;
1796         snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
1797         return 0;
1798 }
1799
1800 /*
1801  * Analog capture
1802  */
1803 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
1804                                    struct hda_codec *codec,
1805                                    unsigned int stream_tag,
1806                                    unsigned int format,
1807                                    struct snd_pcm_substream *substream)
1808 {
1809         struct via_spec *spec = codec->spec;
1810
1811         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
1812                                    stream_tag, 0, format);
1813         return 0;
1814 }
1815
1816 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
1817                                    struct hda_codec *codec,
1818                                    struct snd_pcm_substream *substream)
1819 {
1820         struct via_spec *spec = codec->spec;
1821         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
1822         return 0;
1823 }
1824
1825 static struct hda_pcm_stream vt1708_pcm_analog_playback = {
1826         .substreams = 2,
1827         .channels_min = 2,
1828         .channels_max = 8,
1829         .nid = 0x10, /* NID to query formats and rates */
1830         .ops = {
1831                 .open = via_playback_pcm_open,
1832                 .prepare = via_playback_multi_pcm_prepare,
1833                 .cleanup = via_playback_multi_pcm_cleanup
1834         },
1835 };
1836
1837 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
1838         .substreams = 2,
1839         .channels_min = 2,
1840         .channels_max = 8,
1841         .nid = 0x10, /* NID to query formats and rates */
1842         /* We got noisy outputs on the right channel on VT1708 when
1843          * 24bit samples are used.  Until any workaround is found,
1844          * disable the 24bit format, so far.
1845          */
1846         .formats = SNDRV_PCM_FMTBIT_S16_LE,
1847         .ops = {
1848                 .open = via_playback_pcm_open,
1849                 .prepare = via_playback_multi_pcm_prepare,
1850                 .cleanup = via_playback_multi_pcm_cleanup
1851         },
1852 };
1853
1854 static struct hda_pcm_stream vt1708_pcm_analog_capture = {
1855         .substreams = 2,
1856         .channels_min = 2,
1857         .channels_max = 2,
1858         .nid = 0x15, /* NID to query formats and rates */
1859         .ops = {
1860                 .prepare = via_capture_pcm_prepare,
1861                 .cleanup = via_capture_pcm_cleanup
1862         },
1863 };
1864
1865 static struct hda_pcm_stream vt1708_pcm_digital_playback = {
1866         .substreams = 1,
1867         .channels_min = 2,
1868         .channels_max = 2,
1869         /* NID is set in via_build_pcms */
1870         .ops = {
1871                 .open = via_dig_playback_pcm_open,
1872                 .close = via_dig_playback_pcm_close,
1873                 .prepare = via_dig_playback_pcm_prepare,
1874                 .cleanup = via_dig_playback_pcm_cleanup
1875         },
1876 };
1877
1878 static struct hda_pcm_stream vt1708_pcm_digital_capture = {
1879         .substreams = 1,
1880         .channels_min = 2,
1881         .channels_max = 2,
1882 };
1883
1884 static int via_build_controls(struct hda_codec *codec)
1885 {
1886         struct via_spec *spec = codec->spec;
1887         struct snd_kcontrol *kctl;
1888         struct snd_kcontrol_new *knew;
1889         int err, i;
1890
1891         for (i = 0; i < spec->num_mixers; i++) {
1892                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1893                 if (err < 0)
1894                         return err;
1895         }
1896
1897         if (spec->multiout.dig_out_nid) {
1898                 err = snd_hda_create_spdif_out_ctls(codec,
1899                                                     spec->multiout.dig_out_nid);
1900                 if (err < 0)
1901                         return err;
1902                 err = snd_hda_create_spdif_share_sw(codec,
1903                                                     &spec->multiout);
1904                 if (err < 0)
1905                         return err;
1906                 spec->multiout.share_spdif = 1;
1907         }
1908         if (spec->dig_in_nid) {
1909                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1910                 if (err < 0)
1911                         return err;
1912         }
1913
1914         /* assign Capture Source enums to NID */
1915         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
1916         for (i = 0; kctl && i < kctl->count; i++) {
1917                 err = snd_hda_add_nid(codec, kctl, i, spec->mux_nids[i]);
1918                 if (err < 0)
1919                         return err;
1920         }
1921
1922         /* other nid->control mapping */
1923         for (i = 0; i < spec->num_mixers; i++) {
1924                 for (knew = spec->mixers[i]; knew->name; knew++) {
1925                         if (knew->iface != NID_MAPPING)
1926                                 continue;
1927                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
1928                         if (kctl == NULL)
1929                                 continue;
1930                         err = snd_hda_add_nid(codec, kctl, 0,
1931                                               knew->subdevice);
1932                 }
1933         }
1934
1935         /* init power states */
1936         set_jack_power_state(codec);
1937         analog_low_current_mode(codec, 1);
1938
1939         via_free_kctls(codec); /* no longer needed */
1940         return 0;
1941 }
1942
1943 static int via_build_pcms(struct hda_codec *codec)
1944 {
1945         struct via_spec *spec = codec->spec;
1946         struct hda_pcm *info = spec->pcm_rec;
1947
1948         codec->num_pcms = 1;
1949         codec->pcm_info = info;
1950
1951         info->name = spec->stream_name_analog;
1952         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1953                 *(spec->stream_analog_playback);
1954         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1955                 spec->multiout.dac_nids[0];
1956         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
1957         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
1958
1959         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
1960                 spec->multiout.max_channels;
1961
1962         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
1963                 codec->num_pcms++;
1964                 info++;
1965                 info->name = spec->stream_name_digital;
1966                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
1967                 if (spec->multiout.dig_out_nid) {
1968                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
1969                                 *(spec->stream_digital_playback);
1970                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
1971                                 spec->multiout.dig_out_nid;
1972                 }
1973                 if (spec->dig_in_nid) {
1974                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
1975                                 *(spec->stream_digital_capture);
1976                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
1977                                 spec->dig_in_nid;
1978                 }
1979         }
1980
1981         return 0;
1982 }
1983
1984 static void via_free(struct hda_codec *codec)
1985 {
1986         struct via_spec *spec = codec->spec;
1987
1988         if (!spec)
1989                 return;
1990
1991         via_free_kctls(codec);
1992         vt1708_stop_hp_work(spec);
1993         kfree(codec->spec);
1994 }
1995
1996 /* mute internal speaker if HP is plugged */
1997 static void via_hp_automute(struct hda_codec *codec)
1998 {
1999         unsigned int present = 0;
2000         struct via_spec *spec = codec->spec;
2001
2002         present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
2003
2004         if (!spec->hp_independent_mode) {
2005                 struct snd_ctl_elem_id id;
2006                 /* auto mute */
2007                 snd_hda_codec_amp_stereo(
2008                         codec, spec->autocfg.line_out_pins[0], HDA_OUTPUT, 0,
2009                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
2010                 /* notify change */
2011                 memset(&id, 0, sizeof(id));
2012                 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2013                 strcpy(id.name, "Front Playback Switch");
2014                 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
2015                                &id);
2016         }
2017 }
2018
2019 /* mute mono out if HP or Line out is plugged */
2020 static void via_mono_automute(struct hda_codec *codec)
2021 {
2022         unsigned int hp_present, lineout_present;
2023         struct via_spec *spec = codec->spec;
2024
2025         if (spec->codec_type != VT1716S)
2026                 return;
2027
2028         lineout_present = snd_hda_jack_detect(codec,
2029                                               spec->autocfg.line_out_pins[0]);
2030
2031         /* Mute Mono Out if Line Out is plugged */
2032         if (lineout_present) {
2033                 snd_hda_codec_amp_stereo(
2034                         codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_MUTE);
2035                 return;
2036         }
2037
2038         hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
2039
2040         if (!spec->hp_independent_mode)
2041                 snd_hda_codec_amp_stereo(
2042                         codec, 0x2A, HDA_OUTPUT, 0, HDA_AMP_MUTE,
2043                         hp_present ? HDA_AMP_MUTE : 0);
2044 }
2045
2046 static void via_gpio_control(struct hda_codec *codec)
2047 {
2048         unsigned int gpio_data;
2049         unsigned int vol_counter;
2050         unsigned int vol;
2051         unsigned int master_vol;
2052
2053         struct via_spec *spec = codec->spec;
2054
2055         gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
2056                                        AC_VERB_GET_GPIO_DATA, 0) & 0x03;
2057
2058         vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
2059                                           0xF84, 0) & 0x3F0000) >> 16;
2060
2061         vol = vol_counter & 0x1F;
2062         master_vol = snd_hda_codec_read(codec, 0x1A, 0,
2063                                         AC_VERB_GET_AMP_GAIN_MUTE,
2064                                         AC_AMP_GET_INPUT);
2065
2066         if (gpio_data == 0x02) {
2067                 /* unmute line out */
2068                 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
2069                                          HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
2070
2071                 if (vol_counter & 0x20) {
2072                         /* decrease volume */
2073                         if (vol > master_vol)
2074                                 vol = master_vol;
2075                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
2076                                                  0, HDA_AMP_VOLMASK,
2077                                                  master_vol-vol);
2078                 } else {
2079                         /* increase volume */
2080                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
2081                                          HDA_AMP_VOLMASK,
2082                                          ((master_vol+vol) > 0x2A) ? 0x2A :
2083                                           (master_vol+vol));
2084                 }
2085         } else if (!(gpio_data & 0x02)) {
2086                 /* mute line out */
2087                 snd_hda_codec_amp_stereo(codec,
2088                                          spec->autocfg.line_out_pins[0],
2089                                          HDA_OUTPUT, 0, HDA_AMP_MUTE,
2090                                          HDA_AMP_MUTE);
2091         }
2092 }
2093
2094 /* mute Internal-Speaker if HP is plugged */
2095 static void via_speaker_automute(struct hda_codec *codec)
2096 {
2097         unsigned int hp_present;
2098         struct via_spec *spec = codec->spec;
2099
2100         if (spec->codec_type != VT2002P && spec->codec_type != VT1812)
2101                 return;
2102
2103         hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
2104
2105         if (!spec->hp_independent_mode) {
2106                 struct snd_ctl_elem_id id;
2107                 snd_hda_codec_amp_stereo(
2108                         codec, spec->autocfg.speaker_pins[0], HDA_OUTPUT, 0,
2109                         HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0);
2110                 /* notify change */
2111                 memset(&id, 0, sizeof(id));
2112                 id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
2113                 strcpy(id.name, "Speaker Playback Switch");
2114                 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE,
2115                                &id);
2116         }
2117 }
2118
2119 /* mute line-out and internal speaker if HP is plugged */
2120 static void via_hp_bind_automute(struct hda_codec *codec)
2121 {
2122         /* use long instead of int below just to avoid an internal compiler
2123          * error with gcc 4.0.x
2124          */
2125         unsigned long hp_present, present = 0;
2126         struct via_spec *spec = codec->spec;
2127         int i;
2128
2129         if (!spec->autocfg.hp_pins[0] || !spec->autocfg.line_out_pins[0])
2130                 return;
2131
2132         hp_present = snd_hda_jack_detect(codec, spec->autocfg.hp_pins[0]);
2133
2134         present = snd_hda_jack_detect(codec, spec->autocfg.line_out_pins[0]);
2135
2136         if (!spec->hp_independent_mode) {
2137                 /* Mute Line-Outs */
2138                 for (i = 0; i < spec->autocfg.line_outs; i++)
2139                         snd_hda_codec_amp_stereo(
2140                                 codec, spec->autocfg.line_out_pins[i],
2141                                 HDA_OUTPUT, 0,
2142                                 HDA_AMP_MUTE, hp_present ? HDA_AMP_MUTE : 0);
2143                 if (hp_present)
2144                         present = hp_present;
2145         }
2146         /* Speakers */
2147         for (i = 0; i < spec->autocfg.speaker_outs; i++)
2148                 snd_hda_codec_amp_stereo(
2149                         codec, spec->autocfg.speaker_pins[i], HDA_OUTPUT, 0,
2150                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
2151 }
2152
2153
2154 /* unsolicited event for jack sensing */
2155 static void via_unsol_event(struct hda_codec *codec,
2156                                   unsigned int res)
2157 {
2158         res >>= 26;
2159         if (res & VIA_HP_EVENT)
2160                 via_hp_automute(codec);
2161         if (res & VIA_GPIO_EVENT)
2162                 via_gpio_control(codec);
2163         if (res & VIA_JACK_EVENT)
2164                 set_jack_power_state(codec);
2165         if (res & VIA_MONO_EVENT)
2166                 via_mono_automute(codec);
2167         if (res & VIA_SPEAKER_EVENT)
2168                 via_speaker_automute(codec);
2169         if (res & VIA_BIND_HP_EVENT)
2170                 via_hp_bind_automute(codec);
2171 }
2172
2173 static int via_init(struct hda_codec *codec)
2174 {
2175         struct via_spec *spec = codec->spec;
2176         int i;
2177         for (i = 0; i < spec->num_iverbs; i++)
2178                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
2179
2180         spec->codec_type = get_codec_type(codec);
2181         if (spec->codec_type == VT1708BCE)
2182                 spec->codec_type = VT1708S; /* VT1708BCE & VT1708S are almost
2183                                                same */
2184         /* Lydia Add for EAPD enable */
2185         if (!spec->dig_in_nid) { /* No Digital In connection */
2186                 if (spec->dig_in_pin) {
2187                         snd_hda_codec_write(codec, spec->dig_in_pin, 0,
2188                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
2189                                             PIN_OUT);
2190                         snd_hda_codec_write(codec, spec->dig_in_pin, 0,
2191                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
2192                 }
2193         } else /* enable SPDIF-input pin */
2194                 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
2195                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
2196
2197         /* assign slave outs */
2198         if (spec->slave_dig_outs[0])
2199                 codec->slave_dig_outs = spec->slave_dig_outs;
2200
2201         return 0;
2202 }
2203
2204 #ifdef SND_HDA_NEEDS_RESUME
2205 static int via_suspend(struct hda_codec *codec, pm_message_t state)
2206 {
2207         struct via_spec *spec = codec->spec;
2208         vt1708_stop_hp_work(spec);
2209         return 0;
2210 }
2211 #endif
2212
2213 #ifdef CONFIG_SND_HDA_POWER_SAVE
2214 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
2215 {
2216         struct via_spec *spec = codec->spec;
2217         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
2218 }
2219 #endif
2220
2221 /*
2222  */
2223 static struct hda_codec_ops via_patch_ops = {
2224         .build_controls = via_build_controls,
2225         .build_pcms = via_build_pcms,
2226         .init = via_init,
2227         .free = via_free,
2228 #ifdef SND_HDA_NEEDS_RESUME
2229         .suspend = via_suspend,
2230 #endif
2231 #ifdef CONFIG_SND_HDA_POWER_SAVE
2232         .check_power_status = via_check_power_status,
2233 #endif
2234 };
2235
2236 /* fill in the dac_nids table from the parsed pin configuration */
2237 static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
2238                                      const struct auto_pin_cfg *cfg)
2239 {
2240         int i;
2241         hda_nid_t nid;
2242
2243         spec->multiout.num_dacs = cfg->line_outs;
2244
2245         spec->multiout.dac_nids = spec->private_dac_nids;
2246
2247         for (i = 0; i < 4; i++) {
2248                 nid = cfg->line_out_pins[i];
2249                 if (nid) {
2250                         /* config dac list */
2251                         switch (i) {
2252                         case AUTO_SEQ_FRONT:
2253                                 spec->multiout.dac_nids[i] = 0x10;
2254                                 break;
2255                         case AUTO_SEQ_CENLFE:
2256                                 spec->multiout.dac_nids[i] = 0x12;
2257                                 break;
2258                         case AUTO_SEQ_SURROUND:
2259                                 spec->multiout.dac_nids[i] = 0x11;
2260                                 break;
2261                         case AUTO_SEQ_SIDE:
2262                                 spec->multiout.dac_nids[i] = 0x13;
2263                                 break;
2264                         }
2265                 }
2266         }
2267
2268         return 0;
2269 }
2270
2271 /* add playback controls from the parsed DAC table */
2272 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
2273                                              const struct auto_pin_cfg *cfg)
2274 {
2275         char name[32];
2276         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2277         hda_nid_t nid, nid_vol, nid_vols[] = {0x17, 0x19, 0x1a, 0x1b};
2278         int i, err;
2279
2280         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2281                 nid = cfg->line_out_pins[i];
2282
2283                 if (!nid)
2284                         continue;
2285
2286                 nid_vol = nid_vols[i];
2287
2288                 if (i == AUTO_SEQ_CENLFE) {
2289                         /* Center/LFE */
2290                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2291                                         "Center Playback Volume",
2292                                         HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2293                                                             HDA_OUTPUT));
2294                         if (err < 0)
2295                                 return err;
2296                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2297                                               "LFE Playback Volume",
2298                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2299                                                                   HDA_OUTPUT));
2300                         if (err < 0)
2301                                 return err;
2302                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2303                                               "Center Playback Switch",
2304                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2305                                                                   HDA_OUTPUT));
2306                         if (err < 0)
2307                                 return err;
2308                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2309                                               "LFE Playback Switch",
2310                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2311                                                                   HDA_OUTPUT));
2312                         if (err < 0)
2313                                 return err;
2314                 } else if (i == AUTO_SEQ_FRONT) {
2315                         /* add control to mixer index 0 */
2316                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2317                                               "Master Front Playback Volume",
2318                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2319                                                                   HDA_INPUT));
2320                         if (err < 0)
2321                                 return err;
2322                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2323                                               "Master Front Playback Switch",
2324                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2325                                                                   HDA_INPUT));
2326                         if (err < 0)
2327                                 return err;
2328
2329                         /* add control to PW3 */
2330                         sprintf(name, "%s Playback Volume", chname[i]);
2331                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2332                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2333                                                                   HDA_OUTPUT));
2334                         if (err < 0)
2335                                 return err;
2336                         sprintf(name, "%s Playback Switch", chname[i]);
2337                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2338                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2339                                                                   HDA_OUTPUT));
2340                         if (err < 0)
2341                                 return err;
2342                 } else {
2343                         sprintf(name, "%s Playback Volume", chname[i]);
2344                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2345                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2346                                                                   HDA_OUTPUT));
2347                         if (err < 0)
2348                                 return err;
2349                         sprintf(name, "%s Playback Switch", chname[i]);
2350                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2351                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2352                                                                   HDA_OUTPUT));
2353                         if (err < 0)
2354                                 return err;
2355                 }
2356         }
2357
2358         return 0;
2359 }
2360
2361 static void create_hp_imux(struct via_spec *spec)
2362 {
2363         int i;
2364         struct hda_input_mux *imux = &spec->private_imux[1];
2365         static const char *texts[] = { "OFF", "ON", NULL};
2366
2367         /* for hp mode select */
2368         i = 0;
2369         while (texts[i] != NULL) {
2370                 imux->items[imux->num_items].label =  texts[i];
2371                 imux->items[imux->num_items].index = i;
2372                 imux->num_items++;
2373                 i++;
2374         }
2375
2376         spec->hp_mux = &spec->private_imux[1];
2377 }
2378
2379 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2380 {
2381         int err;
2382
2383         if (!pin)
2384                 return 0;
2385
2386         spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
2387         spec->hp_independent_mode_index = 1;
2388
2389         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2390                               "Headphone Playback Volume",
2391                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2392         if (err < 0)
2393                 return err;
2394         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2395                               "Headphone Playback Switch",
2396                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2397         if (err < 0)
2398                 return err;
2399
2400         create_hp_imux(spec);
2401
2402         return 0;
2403 }
2404
2405 /* create playback/capture controls for input pins */
2406 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
2407                                                 const struct auto_pin_cfg *cfg)
2408 {
2409         static char *labels[] = {
2410                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2411         };
2412         struct hda_input_mux *imux = &spec->private_imux[0];
2413         int i, err, idx = 0;
2414
2415         /* for internal loopback recording select */
2416         imux->items[imux->num_items].label = "Stereo Mixer";
2417         imux->items[imux->num_items].index = idx;
2418         imux->num_items++;
2419
2420         for (i = 0; i < AUTO_PIN_LAST; i++) {
2421                 if (!cfg->input_pins[i])
2422                         continue;
2423
2424                 switch (cfg->input_pins[i]) {
2425                 case 0x1d: /* Mic */
2426                         idx = 2;
2427                         break;
2428
2429                 case 0x1e: /* Line In */
2430                         idx = 3;
2431                         break;
2432
2433                 case 0x21: /* Front Mic */
2434                         idx = 4;
2435                         break;
2436
2437                 case 0x24: /* CD */
2438                         idx = 1;
2439                         break;
2440                 }
2441                 err = via_new_analog_input(spec, labels[i], idx, 0x17);
2442                 if (err < 0)
2443                         return err;
2444                 imux->items[imux->num_items].label = labels[i];
2445                 imux->items[imux->num_items].index = idx;
2446                 imux->num_items++;
2447         }
2448         return 0;
2449 }
2450
2451 #ifdef CONFIG_SND_HDA_POWER_SAVE
2452 static struct hda_amp_list vt1708_loopbacks[] = {
2453         { 0x17, HDA_INPUT, 1 },
2454         { 0x17, HDA_INPUT, 2 },
2455         { 0x17, HDA_INPUT, 3 },
2456         { 0x17, HDA_INPUT, 4 },
2457         { } /* end */
2458 };
2459 #endif
2460
2461 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
2462 {
2463         unsigned int def_conf;
2464         unsigned char seqassoc;
2465
2466         def_conf = snd_hda_codec_get_pincfg(codec, nid);
2467         seqassoc = (unsigned char) get_defcfg_association(def_conf);
2468         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
2469         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE
2470             && (seqassoc == 0xf0 || seqassoc == 0xff)) {
2471                 def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
2472                 snd_hda_codec_set_pincfg(codec, nid, def_conf);
2473         }
2474
2475         return;
2476 }
2477
2478 static int vt1708_jack_detectect_get(struct snd_kcontrol *kcontrol,
2479                                      struct snd_ctl_elem_value *ucontrol)
2480 {
2481         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2482         struct via_spec *spec = codec->spec;
2483
2484         if (spec->codec_type != VT1708)
2485                 return 0;
2486         spec->vt1708_jack_detectect =
2487                 !((snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8) & 0x1);
2488         ucontrol->value.integer.value[0] = spec->vt1708_jack_detectect;
2489         return 0;
2490 }
2491
2492 static int vt1708_jack_detectect_put(struct snd_kcontrol *kcontrol,
2493                                      struct snd_ctl_elem_value *ucontrol)
2494 {
2495         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2496         struct via_spec *spec = codec->spec;
2497         int change;
2498
2499         if (spec->codec_type != VT1708)
2500                 return 0;
2501         spec->vt1708_jack_detectect = ucontrol->value.integer.value[0];
2502         change = (0x1 & (snd_hda_codec_read(codec, 0x1, 0, 0xf84, 0) >> 8))
2503                 == !spec->vt1708_jack_detectect;
2504         if (spec->vt1708_jack_detectect) {
2505                 mute_aa_path(codec, 1);
2506                 notify_aa_path_ctls(codec);
2507         }
2508         return change;
2509 }
2510
2511 static struct snd_kcontrol_new vt1708_jack_detectect[] = {
2512         {
2513                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2514                 .name = "Jack Detect",
2515                 .count = 1,
2516                 .info = snd_ctl_boolean_mono_info,
2517                 .get = vt1708_jack_detectect_get,
2518                 .put = vt1708_jack_detectect_put,
2519         },
2520         {} /* end */
2521 };
2522
2523 static int vt1708_parse_auto_config(struct hda_codec *codec)
2524 {
2525         struct via_spec *spec = codec->spec;
2526         int err;
2527
2528         /* Add HP and CD pin config connect bit re-config action */
2529         vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
2530         vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
2531
2532         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2533         if (err < 0)
2534                 return err;
2535         err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
2536         if (err < 0)
2537                 return err;
2538         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2539                 return 0; /* can't find valid BIOS pin config */
2540
2541         err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
2542         if (err < 0)
2543                 return err;
2544         err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2545         if (err < 0)
2546                 return err;
2547         err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
2548         if (err < 0)
2549                 return err;
2550         /* add jack detect on/off control */
2551         err = snd_hda_add_new_ctls(codec, vt1708_jack_detectect);
2552         if (err < 0)
2553                 return err;
2554
2555         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2556
2557         if (spec->autocfg.dig_outs)
2558                 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
2559         spec->dig_in_pin = VT1708_DIGIN_PIN;
2560         if (spec->autocfg.dig_in_pin)
2561                 spec->dig_in_nid = VT1708_DIGIN_NID;
2562
2563         if (spec->kctls.list)
2564                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
2565
2566         spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs;
2567
2568         spec->input_mux = &spec->private_imux[0];
2569
2570         if (spec->hp_mux)
2571                 via_hp_build(codec);
2572
2573         via_smart51_build(spec);
2574         return 1;
2575 }
2576
2577 /* init callback for auto-configuration model -- overriding the default init */
2578 static int via_auto_init(struct hda_codec *codec)
2579 {
2580         struct via_spec *spec = codec->spec;
2581
2582         via_init(codec);
2583         via_auto_init_multi_out(codec);
2584         via_auto_init_hp_out(codec);
2585         via_auto_init_analog_input(codec);
2586         if (spec->codec_type == VT2002P || spec->codec_type == VT1812) {
2587                 via_hp_bind_automute(codec);
2588         } else {
2589                 via_hp_automute(codec);
2590                 via_speaker_automute(codec);
2591         }
2592
2593         return 0;
2594 }
2595
2596 static void vt1708_update_hp_jack_state(struct work_struct *work)
2597 {
2598         struct via_spec *spec = container_of(work, struct via_spec,
2599                                              vt1708_hp_work.work);
2600         if (spec->codec_type != VT1708)
2601                 return;
2602         /* if jack state toggled */
2603         if (spec->vt1708_hp_present
2604             != snd_hda_jack_detect(spec->codec, spec->autocfg.hp_pins[0])) {
2605                 spec->vt1708_hp_present ^= 1;
2606                 via_hp_automute(spec->codec);
2607         }
2608         vt1708_start_hp_work(spec);
2609 }
2610
2611 static int get_mux_nids(struct hda_codec *codec)
2612 {
2613         struct via_spec *spec = codec->spec;
2614         hda_nid_t nid, conn[8];
2615         unsigned int type;
2616         int i, n;
2617
2618         for (i = 0; i < spec->num_adc_nids; i++) {
2619                 nid = spec->adc_nids[i];
2620                 while (nid) {
2621                         type = get_wcaps_type(get_wcaps(codec, nid));
2622                         if (type == AC_WID_PIN)
2623                                 break;
2624                         n = snd_hda_get_connections(codec, nid, conn,
2625                                                     ARRAY_SIZE(conn));
2626                         if (n <= 0)
2627                                 break;
2628                         if (n > 1) {
2629                                 spec->mux_nids[i] = nid;
2630                                 break;
2631                         }
2632                         nid = conn[0];
2633                 }
2634         }
2635         return 0;
2636 }
2637
2638 static int patch_vt1708(struct hda_codec *codec)
2639 {
2640         struct via_spec *spec;
2641         int err;
2642
2643         /* create a codec specific record */
2644         spec = via_new_spec(codec);
2645         if (spec == NULL)
2646                 return -ENOMEM;
2647
2648         /* automatic parse from the BIOS config */
2649         err = vt1708_parse_auto_config(codec);
2650         if (err < 0) {
2651                 via_free(codec);
2652                 return err;
2653         } else if (!err) {
2654                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2655                        "from BIOS.  Using genenic mode...\n");
2656         }
2657
2658
2659         spec->stream_name_analog = "VT1708 Analog";
2660         spec->stream_analog_playback = &vt1708_pcm_analog_playback;
2661         /* disable 32bit format on VT1708 */
2662         if (codec->vendor_id == 0x11061708)
2663                 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
2664         spec->stream_analog_capture = &vt1708_pcm_analog_capture;
2665
2666         spec->stream_name_digital = "VT1708 Digital";
2667         spec->stream_digital_playback = &vt1708_pcm_digital_playback;
2668         spec->stream_digital_capture = &vt1708_pcm_digital_capture;
2669
2670
2671         if (!spec->adc_nids && spec->input_mux) {
2672                 spec->adc_nids = vt1708_adc_nids;
2673                 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
2674                 get_mux_nids(codec);
2675                 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
2676                 spec->num_mixers++;
2677         }
2678
2679         codec->patch_ops = via_patch_ops;
2680
2681         codec->patch_ops.init = via_auto_init;
2682 #ifdef CONFIG_SND_HDA_POWER_SAVE
2683         spec->loopback.amplist = vt1708_loopbacks;
2684 #endif
2685         INIT_DELAYED_WORK(&spec->vt1708_hp_work, vt1708_update_hp_jack_state);
2686         return 0;
2687 }
2688
2689 /* capture mixer elements */
2690 static struct snd_kcontrol_new vt1709_capture_mixer[] = {
2691         HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
2692         HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
2693         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
2694         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
2695         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
2696         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
2697         {
2698                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2699                 /* The multiple "Capture Source" controls confuse alsamixer
2700                  * So call somewhat different..
2701                  */
2702                 /* .name = "Capture Source", */
2703                 .name = "Input Source",
2704                 .count = 1,
2705                 .info = via_mux_enum_info,
2706                 .get = via_mux_enum_get,
2707                 .put = via_mux_enum_put,
2708         },
2709         { } /* end */
2710 };
2711
2712 static struct hda_verb vt1709_uniwill_init_verbs[] = {
2713         {0x20, AC_VERB_SET_UNSOLICITED_ENABLE,
2714          AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
2715         { }
2716 };
2717
2718 /*
2719  * generic initialization of ADC, input mixers and output mixers
2720  */
2721 static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
2722         /*
2723          * Unmute ADC0-2 and set the default input to mic-in
2724          */
2725         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2726         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2727         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2728
2729
2730         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2731          * mixer widget
2732          */
2733         /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2734         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2735         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2736         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2737         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2738         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2739
2740         /*
2741          * Set up output selector (0x1a, 0x1b, 0x29)
2742          */
2743         /* set vol=0 to output mixers */
2744         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2745         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2746         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2747
2748         /*
2749          *  Unmute PW3 and PW4
2750          */
2751         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2752         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2753
2754         /* Set input of PW4 as MW0 */
2755         {0x20, AC_VERB_SET_CONNECT_SEL, 0},
2756         /* PW9 Output enable */
2757         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2758         { }
2759 };
2760
2761 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
2762         .substreams = 1,
2763         .channels_min = 2,
2764         .channels_max = 10,
2765         .nid = 0x10, /* NID to query formats and rates */
2766         .ops = {
2767                 .open = via_playback_pcm_open,
2768                 .prepare = via_playback_multi_pcm_prepare,
2769                 .cleanup = via_playback_multi_pcm_cleanup,
2770         },
2771 };
2772
2773 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
2774         .substreams = 1,
2775         .channels_min = 2,
2776         .channels_max = 6,
2777         .nid = 0x10, /* NID to query formats and rates */
2778         .ops = {
2779                 .open = via_playback_pcm_open,
2780                 .prepare = via_playback_multi_pcm_prepare,
2781                 .cleanup = via_playback_multi_pcm_cleanup,
2782         },
2783 };
2784
2785 static struct hda_pcm_stream vt1709_pcm_analog_capture = {
2786         .substreams = 2,
2787         .channels_min = 2,
2788         .channels_max = 2,
2789         .nid = 0x14, /* NID to query formats and rates */
2790         .ops = {
2791                 .prepare = via_capture_pcm_prepare,
2792                 .cleanup = via_capture_pcm_cleanup
2793         },
2794 };
2795
2796 static struct hda_pcm_stream vt1709_pcm_digital_playback = {
2797         .substreams = 1,
2798         .channels_min = 2,
2799         .channels_max = 2,
2800         /* NID is set in via_build_pcms */
2801         .ops = {
2802                 .open = via_dig_playback_pcm_open,
2803                 .close = via_dig_playback_pcm_close
2804         },
2805 };
2806
2807 static struct hda_pcm_stream vt1709_pcm_digital_capture = {
2808         .substreams = 1,
2809         .channels_min = 2,
2810         .channels_max = 2,
2811 };
2812
2813 static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
2814                                      const struct auto_pin_cfg *cfg)
2815 {
2816         int i;
2817         hda_nid_t nid;
2818
2819         if (cfg->line_outs == 4)  /* 10 channels */
2820                 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
2821         else if (cfg->line_outs == 3) /* 6 channels */
2822                 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
2823
2824         spec->multiout.dac_nids = spec->private_dac_nids;
2825
2826         if (cfg->line_outs == 4) { /* 10 channels */
2827                 for (i = 0; i < cfg->line_outs; i++) {
2828                         nid = cfg->line_out_pins[i];
2829                         if (nid) {
2830                                 /* config dac list */
2831                                 switch (i) {
2832                                 case AUTO_SEQ_FRONT:
2833                                         /* AOW0 */
2834                                         spec->multiout.dac_nids[i] = 0x10;
2835                                         break;
2836                                 case AUTO_SEQ_CENLFE:
2837                                         /* AOW2 */
2838                                         spec->multiout.dac_nids[i] = 0x12;
2839                                         break;
2840                                 case AUTO_SEQ_SURROUND:
2841                                         /* AOW3 */
2842                                         spec->multiout.dac_nids[i] = 0x11;
2843                                         break;
2844                                 case AUTO_SEQ_SIDE:
2845                                         /* AOW1 */
2846                                         spec->multiout.dac_nids[i] = 0x27;
2847                                         break;
2848                                 default:
2849                                         break;
2850                                 }
2851                         }
2852                 }
2853                 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
2854
2855         } else if (cfg->line_outs == 3) { /* 6 channels */
2856                 for (i = 0; i < cfg->line_outs; i++) {
2857                         nid = cfg->line_out_pins[i];
2858                         if (nid) {
2859                                 /* config dac list */
2860                                 switch (i) {
2861                                 case AUTO_SEQ_FRONT:
2862                                         /* AOW0 */
2863                                         spec->multiout.dac_nids[i] = 0x10;
2864                                         break;
2865                                 case AUTO_SEQ_CENLFE:
2866                                         /* AOW2 */
2867                                         spec->multiout.dac_nids[i] = 0x12;
2868                                         break;
2869                                 case AUTO_SEQ_SURROUND:
2870                                         /* AOW1 */
2871                                         spec->multiout.dac_nids[i] = 0x11;
2872                                         break;
2873                                 default:
2874                                         break;
2875                                 }
2876                         }
2877                 }
2878         }
2879
2880         return 0;
2881 }
2882
2883 /* add playback controls from the parsed DAC table */
2884 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
2885                                              const struct auto_pin_cfg *cfg)
2886 {
2887         char name[32];
2888         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2889         hda_nid_t nid, nid_vol, nid_vols[] = {0x18, 0x1a, 0x1b, 0x29};
2890         int i, err;
2891
2892         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2893                 nid = cfg->line_out_pins[i];
2894
2895                 if (!nid)
2896                         continue;
2897
2898                 nid_vol = nid_vols[i];
2899
2900                 if (i == AUTO_SEQ_CENLFE) {
2901                         /* Center/LFE */
2902                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2903                                               "Center Playback Volume",
2904                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2905                                                                   HDA_OUTPUT));
2906                         if (err < 0)
2907                                 return err;
2908                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2909                                               "LFE Playback Volume",
2910                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2911                                                                   HDA_OUTPUT));
2912                         if (err < 0)
2913                                 return err;
2914                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2915                                               "Center Playback Switch",
2916                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2917                                                                   HDA_OUTPUT));
2918                         if (err < 0)
2919                                 return err;
2920                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2921                                               "LFE Playback Switch",
2922                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2923                                                                   HDA_OUTPUT));
2924                         if (err < 0)
2925                                 return err;
2926                 } else if (i == AUTO_SEQ_FRONT) {
2927                         /* ADD control to mixer index 0 */
2928                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2929                                               "Master Front Playback Volume",
2930                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2931                                                                   HDA_INPUT));
2932                         if (err < 0)
2933                                 return err;
2934                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2935                                               "Master Front Playback Switch",
2936                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2937                                                                   HDA_INPUT));
2938                         if (err < 0)
2939                                 return err;
2940
2941                         /* add control to PW3 */
2942                         sprintf(name, "%s Playback Volume", chname[i]);
2943                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2944                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2945                                                                   HDA_OUTPUT));
2946                         if (err < 0)
2947                                 return err;
2948                         sprintf(name, "%s Playback Switch", chname[i]);
2949                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2950                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2951                                                                   HDA_OUTPUT));
2952                         if (err < 0)
2953                                 return err;
2954                 } else if (i == AUTO_SEQ_SURROUND) {
2955                         sprintf(name, "%s Playback Volume", chname[i]);
2956                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2957                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2958                                                                   HDA_OUTPUT));
2959                         if (err < 0)
2960                                 return err;
2961                         sprintf(name, "%s Playback Switch", chname[i]);
2962                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2963                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2964                                                                   HDA_OUTPUT));
2965                         if (err < 0)
2966                                 return err;
2967                 } else if (i == AUTO_SEQ_SIDE) {
2968                         sprintf(name, "%s Playback Volume", chname[i]);
2969                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2970                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2971                                                                   HDA_OUTPUT));
2972                         if (err < 0)
2973                                 return err;
2974                         sprintf(name, "%s Playback Switch", chname[i]);
2975                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2976                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2977                                                                   HDA_OUTPUT));
2978                         if (err < 0)
2979                                 return err;
2980                 }
2981         }
2982
2983         return 0;
2984 }
2985
2986 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2987 {
2988         int err;
2989
2990         if (!pin)
2991                 return 0;
2992
2993         if (spec->multiout.num_dacs == 5) /* 10 channels */
2994                 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
2995         else if (spec->multiout.num_dacs == 3) /* 6 channels */
2996                 spec->multiout.hp_nid = 0;
2997         spec->hp_independent_mode_index = 1;
2998
2999         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3000                               "Headphone Playback Volume",
3001                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3002         if (err < 0)
3003                 return err;
3004         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3005                               "Headphone Playback Switch",
3006                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3007         if (err < 0)
3008                 return err;
3009
3010         return 0;
3011 }
3012
3013 /* create playback/capture controls for input pins */
3014 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
3015                                                 const struct auto_pin_cfg *cfg)
3016 {
3017         static char *labels[] = {
3018                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
3019         };
3020         struct hda_input_mux *imux = &spec->private_imux[0];
3021         int i, err, idx = 0;
3022
3023         /* for internal loopback recording select */
3024         imux->items[imux->num_items].label = "Stereo Mixer";
3025         imux->items[imux->num_items].index = idx;
3026         imux->num_items++;
3027
3028         for (i = 0; i < AUTO_PIN_LAST; i++) {
3029                 if (!cfg->input_pins[i])
3030                         continue;
3031
3032                 switch (cfg->input_pins[i]) {
3033                 case 0x1d: /* Mic */
3034                         idx = 2;
3035                         break;
3036
3037                 case 0x1e: /* Line In */
3038                         idx = 3;
3039                         break;
3040
3041                 case 0x21: /* Front Mic */
3042                         idx = 4;
3043                         break;
3044
3045                 case 0x23: /* CD */
3046                         idx = 1;
3047                         break;
3048                 }
3049                 err = via_new_analog_input(spec, labels[i], idx, 0x18);
3050                 if (err < 0)
3051                         return err;
3052                 imux->items[imux->num_items].label = labels[i];
3053                 imux->items[imux->num_items].index = idx;
3054                 imux->num_items++;
3055         }
3056         return 0;
3057 }
3058
3059 static int vt1709_parse_auto_config(struct hda_codec *codec)
3060 {
3061         struct via_spec *spec = codec->spec;
3062         int err;
3063
3064         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
3065         if (err < 0)
3066                 return err;
3067         err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
3068         if (err < 0)
3069                 return err;
3070         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
3071                 return 0; /* can't find valid BIOS pin config */
3072
3073         err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
3074         if (err < 0)
3075                 return err;
3076         err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
3077         if (err < 0)
3078                 return err;
3079         err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
3080         if (err < 0)
3081                 return err;
3082
3083         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3084
3085         if (spec->autocfg.dig_outs)
3086                 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
3087         spec->dig_in_pin = VT1709_DIGIN_PIN;
3088         if (spec->autocfg.dig_in_pin)
3089                 spec->dig_in_nid = VT1709_DIGIN_NID;
3090
3091         if (spec->kctls.list)
3092                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3093
3094         spec->input_mux = &spec->private_imux[0];
3095
3096         if (spec->hp_mux)
3097                 via_hp_build(codec);
3098
3099         via_smart51_build(spec);
3100         return 1;
3101 }
3102
3103 #ifdef CONFIG_SND_HDA_POWER_SAVE
3104 static struct hda_amp_list vt1709_loopbacks[] = {
3105         { 0x18, HDA_INPUT, 1 },
3106         { 0x18, HDA_INPUT, 2 },
3107         { 0x18, HDA_INPUT, 3 },
3108         { 0x18, HDA_INPUT, 4 },
3109         { } /* end */
3110 };
3111 #endif
3112
3113 static int patch_vt1709_10ch(struct hda_codec *codec)
3114 {
3115         struct via_spec *spec;
3116         int err;
3117
3118         /* create a codec specific record */
3119         spec = via_new_spec(codec);
3120         if (spec == NULL)
3121                 return -ENOMEM;
3122
3123         err = vt1709_parse_auto_config(codec);
3124         if (err < 0) {
3125                 via_free(codec);
3126                 return err;
3127         } else if (!err) {
3128                 printk(KERN_INFO "hda_codec: Cannot set up configuration.  "
3129                        "Using genenic mode...\n");
3130         }
3131
3132         spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs;
3133         spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
3134
3135         spec->stream_name_analog = "VT1709 Analog";
3136         spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
3137         spec->stream_analog_capture = &vt1709_pcm_analog_capture;
3138
3139         spec->stream_name_digital = "VT1709 Digital";
3140         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
3141         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
3142
3143
3144         if (!spec->adc_nids && spec->input_mux) {
3145                 spec->adc_nids = vt1709_adc_nids;
3146                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
3147                 get_mux_nids(codec);
3148                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
3149                 spec->num_mixers++;
3150         }
3151
3152         codec->patch_ops = via_patch_ops;
3153
3154         codec->patch_ops.init = via_auto_init;
3155         codec->patch_ops.unsol_event = via_unsol_event;
3156 #ifdef CONFIG_SND_HDA_POWER_SAVE
3157         spec->loopback.amplist = vt1709_loopbacks;
3158 #endif
3159
3160         return 0;
3161 }
3162 /*
3163  * generic initialization of ADC, input mixers and output mixers
3164  */
3165 static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
3166         /*
3167          * Unmute ADC0-2 and set the default input to mic-in
3168          */
3169         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3170         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3171         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3172
3173
3174         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3175          * mixer widget
3176          */
3177         /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
3178         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3179         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3180         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3181         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
3182         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3183
3184         /*
3185          * Set up output selector (0x1a, 0x1b, 0x29)
3186          */
3187         /* set vol=0 to output mixers */
3188         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3189         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3190         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3191
3192         /*
3193          *  Unmute PW3 and PW4
3194          */
3195         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3196         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3197
3198         /* Set input of PW4 as MW0 */
3199         {0x20, AC_VERB_SET_CONNECT_SEL, 0},
3200         /* PW9 Output enable */
3201         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3202         { }
3203 };
3204
3205 static int patch_vt1709_6ch(struct hda_codec *codec)
3206 {
3207         struct via_spec *spec;
3208         int err;
3209
3210         /* create a codec specific record */
3211         spec = via_new_spec(codec);
3212         if (spec == NULL)
3213                 return -ENOMEM;
3214
3215         err = vt1709_parse_auto_config(codec);
3216         if (err < 0) {
3217                 via_free(codec);
3218                 return err;
3219         } else if (!err) {
3220                 printk(KERN_INFO "hda_codec: Cannot set up configuration.  "
3221                        "Using genenic mode...\n");
3222         }
3223
3224         spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs;
3225         spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
3226
3227         spec->stream_name_analog = "VT1709 Analog";
3228         spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
3229         spec->stream_analog_capture = &vt1709_pcm_analog_capture;
3230
3231         spec->stream_name_digital = "VT1709 Digital";
3232         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
3233         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
3234
3235
3236         if (!spec->adc_nids && spec->input_mux) {
3237                 spec->adc_nids = vt1709_adc_nids;
3238                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
3239                 get_mux_nids(codec);
3240                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
3241                 spec->num_mixers++;
3242         }
3243
3244         codec->patch_ops = via_patch_ops;
3245
3246         codec->patch_ops.init = via_auto_init;
3247         codec->patch_ops.unsol_event = via_unsol_event;
3248 #ifdef CONFIG_SND_HDA_POWER_SAVE
3249         spec->loopback.amplist = vt1709_loopbacks;
3250 #endif
3251         return 0;
3252 }
3253
3254 /* capture mixer elements */
3255 static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
3256         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
3257         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
3258         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
3259         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
3260         {
3261                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3262                 /* The multiple "Capture Source" controls confuse alsamixer
3263                  * So call somewhat different..
3264                  */
3265                 /* .name = "Capture Source", */
3266                 .name = "Input Source",
3267                 .count = 1,
3268                 .info = via_mux_enum_info,
3269                 .get = via_mux_enum_get,
3270                 .put = via_mux_enum_put,
3271         },
3272         { } /* end */
3273 };
3274 /*
3275  * generic initialization of ADC, input mixers and output mixers
3276  */
3277 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
3278         /*
3279          * Unmute ADC0-1 and set the default input to mic-in
3280          */
3281         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3282         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3283
3284
3285         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3286          * mixer widget
3287          */
3288         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
3289         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3290         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3291         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3292         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
3293         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3294
3295         /*
3296          * Set up output mixers
3297          */
3298         /* set vol=0 to output mixers */
3299         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3300         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3301         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3302
3303         /* Setup default input to PW4 */
3304         {0x1d, AC_VERB_SET_CONNECT_SEL, 0},
3305         /* PW9 Output enable */
3306         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3307         /* PW10 Input enable */
3308         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3309         { }
3310 };
3311
3312 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
3313         /*
3314          * Unmute ADC0-1 and set the default input to mic-in
3315          */
3316         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3317         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3318
3319
3320         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
3321          * mixer widget
3322          */
3323         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
3324         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3325         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3326         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3327         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
3328         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3329
3330         /*
3331          * Set up output mixers
3332          */
3333         /* set vol=0 to output mixers */
3334         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3335         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3336         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3337
3338         /* Setup default input of PW4 to MW0 */
3339         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
3340         /* PW9 Output enable */
3341         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3342         /* PW10 Input enable */
3343         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
3344         { }
3345 };
3346
3347 static struct hda_verb vt1708B_uniwill_init_verbs[] = {
3348         {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
3349          AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
3350         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3351         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3352         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3353         {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3354         {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3355         {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3356         {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3357         { }
3358 };
3359
3360 static int via_pcm_open_close(struct hda_pcm_stream *hinfo,
3361                               struct hda_codec *codec,
3362                               struct snd_pcm_substream *substream)
3363 {
3364         int idle = substream->pstr->substream_opened == 1
3365                 && substream->ref_count == 0;
3366
3367         analog_low_current_mode(codec, idle);
3368         return 0;
3369 }
3370
3371 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
3372         .substreams = 2,
3373         .channels_min = 2,
3374         .channels_max = 8,
3375         .nid = 0x10, /* NID to query formats and rates */
3376         .ops = {
3377                 .open = via_playback_pcm_open,
3378                 .prepare = via_playback_multi_pcm_prepare,
3379                 .cleanup = via_playback_multi_pcm_cleanup,
3380                 .close = via_pcm_open_close
3381         },
3382 };
3383
3384 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
3385         .substreams = 2,
3386         .channels_min = 2,
3387         .channels_max = 4,
3388         .nid = 0x10, /* NID to query formats and rates */
3389         .ops = {
3390                 .open = via_playback_pcm_open,
3391                 .prepare = via_playback_multi_pcm_prepare,
3392                 .cleanup = via_playback_multi_pcm_cleanup
3393         },
3394 };
3395
3396 static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
3397         .substreams = 2,
3398         .channels_min = 2,
3399         .channels_max = 2,
3400         .nid = 0x13, /* NID to query formats and rates */
3401         .ops = {
3402                 .open = via_pcm_open_close,
3403                 .prepare = via_capture_pcm_prepare,
3404                 .cleanup = via_capture_pcm_cleanup,
3405                 .close = via_pcm_open_close
3406         },
3407 };
3408
3409 static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
3410         .substreams = 1,
3411         .channels_min = 2,
3412         .channels_max = 2,
3413         /* NID is set in via_build_pcms */
3414         .ops = {
3415                 .open = via_dig_playback_pcm_open,
3416                 .close = via_dig_playback_pcm_close,
3417                 .prepare = via_dig_playback_pcm_prepare,
3418                 .cleanup = via_dig_playback_pcm_cleanup
3419         },
3420 };
3421
3422 static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
3423         .substreams = 1,
3424         .channels_min = 2,
3425         .channels_max = 2,
3426 };
3427
3428 /* fill in the dac_nids table from the parsed pin configuration */
3429 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
3430                                      const struct auto_pin_cfg *cfg)
3431 {
3432         int i;
3433         hda_nid_t nid;
3434
3435         spec->multiout.num_dacs = cfg->line_outs;
3436
3437         spec->multiout.dac_nids = spec->private_dac_nids;
3438
3439         for (i = 0; i < 4; i++) {
3440                 nid = cfg->line_out_pins[i];
3441                 if (nid) {
3442                         /* config dac list */
3443                         switch (i) {
3444                         case AUTO_SEQ_FRONT:
3445                                 spec->multiout.dac_nids[i] = 0x10;
3446                                 break;
3447                         case AUTO_SEQ_CENLFE:
3448                                 spec->multiout.dac_nids[i] = 0x24;
3449                                 break;
3450                         case AUTO_SEQ_SURROUND:
3451                                 spec->multiout.dac_nids[i] = 0x11;
3452                                 break;
3453                         case AUTO_SEQ_SIDE:
3454                                 spec->multiout.dac_nids[i] = 0x25;
3455                                 break;
3456                         }
3457                 }
3458         }
3459
3460         return 0;
3461 }
3462
3463 /* add playback controls from the parsed DAC table */
3464 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
3465                                              const struct auto_pin_cfg *cfg)
3466 {
3467         char name[32];
3468         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
3469         hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27};
3470         hda_nid_t nid, nid_vol = 0;
3471         int i, err;
3472
3473         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
3474                 nid = cfg->line_out_pins[i];
3475
3476                 if (!nid)
3477                         continue;
3478
3479                 nid_vol = nid_vols[i];
3480
3481                 if (i == AUTO_SEQ_CENLFE) {
3482                         /* Center/LFE */
3483                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3484                                               "Center Playback Volume",
3485                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
3486                                                                   HDA_OUTPUT));
3487                         if (err < 0)
3488                                 return err;
3489                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3490                                               "LFE Playback Volume",
3491                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
3492                                                                   HDA_OUTPUT));
3493                         if (err < 0)
3494                                 return err;
3495                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3496                                               "Center Playback Switch",
3497                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
3498                                                                   HDA_OUTPUT));
3499                         if (err < 0)
3500                                 return err;
3501                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3502                                               "LFE Playback Switch",
3503                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
3504                                                                   HDA_OUTPUT));
3505                         if (err < 0)
3506                                 return err;
3507                 } else if (i == AUTO_SEQ_FRONT) {
3508                         /* add control to mixer index 0 */
3509                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3510                                               "Master Front Playback Volume",
3511                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
3512                                                                   HDA_INPUT));
3513                         if (err < 0)
3514                                 return err;
3515                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3516                                               "Master Front Playback Switch",
3517                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
3518                                                                   HDA_INPUT));
3519                         if (err < 0)
3520                                 return err;
3521
3522                         /* add control to PW3 */
3523                         sprintf(name, "%s Playback Volume", chname[i]);
3524                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
3525                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3526                                                                   HDA_OUTPUT));
3527                         if (err < 0)
3528                                 return err;
3529                         sprintf(name, "%s Playback Switch", chname[i]);
3530                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
3531                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
3532                                                                   HDA_OUTPUT));
3533                         if (err < 0)
3534                                 return err;
3535                 } else {
3536                         sprintf(name, "%s Playback Volume", chname[i]);
3537                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
3538                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
3539                                                                   HDA_OUTPUT));
3540                         if (err < 0)
3541                                 return err;
3542                         sprintf(name, "%s Playback Switch", chname[i]);
3543                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
3544                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
3545                                                                   HDA_OUTPUT));
3546                         if (err < 0)
3547                                 return err;
3548                 }
3549         }
3550
3551         return 0;
3552 }
3553
3554 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
3555 {
3556         int err;
3557
3558         if (!pin)
3559                 return 0;
3560
3561         spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
3562         spec->hp_independent_mode_index = 1;
3563
3564         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3565                               "Headphone Playback Volume",
3566                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3567         if (err < 0)
3568                 return err;
3569         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3570                               "Headphone Playback Switch",
3571                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3572         if (err < 0)
3573                 return err;
3574
3575         create_hp_imux(spec);
3576
3577         return 0;
3578 }
3579
3580 /* create playback/capture controls for input pins */
3581 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
3582                                                 const struct auto_pin_cfg *cfg)
3583 {
3584         static char *labels[] = {
3585                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
3586         };
3587         struct hda_input_mux *imux = &spec->private_imux[0];
3588         int i, err, idx = 0;
3589
3590         /* for internal loopback recording select */
3591         imux->items[imux->num_items].label = "Stereo Mixer";
3592         imux->items[imux->num_items].index = idx;
3593         imux->num_items++;
3594
3595         for (i = 0; i < AUTO_PIN_LAST; i++) {
3596                 if (!cfg->input_pins[i])
3597                         continue;
3598
3599                 switch (cfg->input_pins[i]) {
3600                 case 0x1a: /* Mic */
3601                         idx = 2;
3602                         break;
3603
3604                 case 0x1b: /* Line In */
3605                         idx = 3;
3606                         break;
3607
3608                 case 0x1e: /* Front Mic */
3609                         idx = 4;
3610                         break;
3611
3612                 case 0x1f: /* CD */
3613                         idx = 1;
3614                         break;
3615                 }
3616                 err = via_new_analog_input(spec, labels[i], idx, 0x16);
3617                 if (err < 0)
3618                         return err;
3619                 imux->items[imux->num_items].label = labels[i];
3620                 imux->items[imux->num_items].index = idx;
3621                 imux->num_items++;
3622         }
3623         return 0;
3624 }
3625
3626 static int vt1708B_parse_auto_config(struct hda_codec *codec)
3627 {
3628         struct via_spec *spec = codec->spec;
3629         int err;
3630
3631         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
3632         if (err < 0)
3633                 return err;
3634         err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
3635         if (err < 0)
3636                 return err;
3637         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
3638                 return 0; /* can't find valid BIOS pin config */
3639
3640         err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
3641         if (err < 0)
3642                 return err;
3643         err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
3644         if (err < 0)
3645                 return err;
3646         err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
3647         if (err < 0)
3648                 return err;
3649
3650         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3651
3652         if (spec->autocfg.dig_outs)
3653                 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
3654         spec->dig_in_pin = VT1708B_DIGIN_PIN;
3655         if (spec->autocfg.dig_in_pin)
3656                 spec->dig_in_nid = VT1708B_DIGIN_NID;
3657
3658         if (spec->kctls.list)
3659                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
3660
3661         spec->input_mux = &spec->private_imux[0];
3662
3663         if (spec->hp_mux)
3664                 via_hp_build(codec);
3665
3666         via_smart51_build(spec);
3667         return 1;
3668 }
3669
3670 #ifdef CONFIG_SND_HDA_POWER_SAVE
3671 static struct hda_amp_list vt1708B_loopbacks[] = {
3672         { 0x16, HDA_INPUT, 1 },
3673         { 0x16, HDA_INPUT, 2 },
3674         { 0x16, HDA_INPUT, 3 },
3675         { 0x16, HDA_INPUT, 4 },
3676         { } /* end */
3677 };
3678 #endif
3679 static int patch_vt1708S(struct hda_codec *codec);
3680 static int patch_vt1708B_8ch(struct hda_codec *codec)
3681 {
3682         struct via_spec *spec;
3683         int err;
3684
3685         if (get_codec_type(codec) == VT1708BCE)
3686                 return patch_vt1708S(codec);
3687         /* create a codec specific record */
3688         spec = via_new_spec(codec);
3689         if (spec == NULL)
3690                 return -ENOMEM;
3691
3692         /* automatic parse from the BIOS config */
3693         err = vt1708B_parse_auto_config(codec);
3694         if (err < 0) {
3695                 via_free(codec);
3696                 return err;
3697         } else if (!err) {
3698                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
3699                        "from BIOS.  Using genenic mode...\n");
3700         }
3701
3702         spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs;
3703         spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
3704
3705         spec->stream_name_analog = "VT1708B Analog";
3706         spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
3707         spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
3708
3709         spec->stream_name_digital = "VT1708B Digital";
3710         spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
3711         spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
3712
3713         if (!spec->adc_nids && spec->input_mux) {
3714                 spec->adc_nids = vt1708B_adc_nids;
3715                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
3716                 get_mux_nids(codec);
3717                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
3718                 spec->num_mixers++;
3719         }
3720
3721         codec->patch_ops = via_patch_ops;
3722
3723         codec->patch_ops.init = via_auto_init;
3724         codec->patch_ops.unsol_event = via_unsol_event;
3725 #ifdef CONFIG_SND_HDA_POWER_SAVE
3726         spec->loopback.amplist = vt1708B_loopbacks;
3727 #endif
3728
3729         return 0;
3730 }
3731
3732 static int patch_vt1708B_4ch(struct hda_codec *codec)
3733 {
3734         struct via_spec *spec;
3735         int err;
3736
3737         /* create a codec specific record */
3738         spec = via_new_spec(codec);
3739         if (spec == NULL)
3740                 return -ENOMEM;
3741
3742         /* automatic parse from the BIOS config */
3743         err = vt1708B_parse_auto_config(codec);
3744         if (err < 0) {
3745                 via_free(codec);
3746                 return err;
3747         } else if (!err) {
3748                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
3749                        "from BIOS.  Using genenic mode...\n");
3750         }
3751
3752         spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs;
3753         spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
3754
3755         spec->stream_name_analog = "VT1708B Analog";
3756         spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
3757         spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
3758
3759         spec->stream_name_digital = "VT1708B Digital";
3760         spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
3761         spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
3762
3763         if (!spec->adc_nids && spec->input_mux) {
3764                 spec->adc_nids = vt1708B_adc_nids;
3765                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
3766                 get_mux_nids(codec);
3767                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
3768                 spec->num_mixers++;
3769         }
3770
3771         codec->patch_ops = via_patch_ops;
3772
3773         codec->patch_ops.init = via_auto_init;
3774         codec->patch_ops.unsol_event = via_unsol_event;
3775 #ifdef CONFIG_SND_HDA_POWER_SAVE
3776         spec->loopback.amplist = vt1708B_loopbacks;
3777 #endif
3778
3779         return 0;
3780 }
3781
3782 /* Patch for VT1708S */
3783
3784 /* capture mixer elements */
3785 static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
3786         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
3787         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
3788         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
3789         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
3790         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT),
3791         HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0,
3792                          HDA_INPUT),
3793         {
3794                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3795                 /* The multiple "Capture Source" controls confuse alsamixer
3796                  * So call somewhat different..
3797                  */
3798                 /* .name = "Capture Source", */
3799                 .name = "Input Source",
3800                 .count = 1,
3801                 .info = via_mux_enum_info,
3802                 .get = via_mux_enum_get,
3803                 .put = via_mux_enum_put,
3804         },
3805         { } /* end */
3806 };
3807
3808 static struct hda_verb vt1708S_volume_init_verbs[] = {
3809         /* Unmute ADC0-1 and set the default input to mic-in */
3810         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3811         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3812
3813         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the
3814          * analog-loopback mixer widget */
3815         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
3816         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3817         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3818         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
3819         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
3820         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
3821
3822         /* Setup default input of PW4 to MW0 */
3823         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
3824         /* PW9, PW10  Output enable */
3825         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3826         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
3827         /* Enable Mic Boost Volume backdoor */
3828         {0x1, 0xf98, 0x1},
3829         /* don't bybass mixer */
3830         {0x1, 0xf88, 0xc0},
3831         { }
3832 };
3833
3834 static struct hda_verb vt1708S_uniwill_init_verbs[] = {
3835         {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
3836          AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
3837         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3838         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3839         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3840         {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3841         {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3842         {0x22, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3843         {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
3844         { }
3845 };
3846
3847 static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
3848         .substreams = 2,
3849         .channels_min = 2,
3850         .channels_max = 8,
3851         .nid = 0x10, /* NID to query formats and rates */
3852         .ops = {
3853                 .open = via_playback_pcm_open,
3854                 .prepare = via_playback_multi_pcm_prepare,
3855                 .cleanup = via_playback_multi_pcm_cleanup,
3856                 .close = via_pcm_open_close
3857         },
3858 };
3859
3860 static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
3861         .substreams = 2,
3862         .channels_min = 2,
3863         .channels_max = 2,
3864         .nid = 0x13, /* NID to query formats and rates */
3865         .ops = {
3866                 .open = via_pcm_open_close,
3867                 .prepare = via_capture_pcm_prepare,
3868                 .cleanup = via_capture_pcm_cleanup,
3869                 .close = via_pcm_open_close
3870         },
3871 };
3872
3873 static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
3874         .substreams = 1,
3875         .channels_min = 2,
3876         .channels_max = 2,
3877         /* NID is set in via_build_pcms */
3878         .ops = {
3879                 .open = via_dig_playback_pcm_open,
3880                 .close = via_dig_playback_pcm_close,
3881                 .prepare = via_dig_playback_pcm_prepare,
3882                 .cleanup = via_dig_playback_pcm_cleanup
3883         },
3884 };
3885
3886 /* fill in the dac_nids table from the parsed pin configuration */
3887 static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
3888                                      const struct auto_pin_cfg *cfg)
3889 {
3890         int i;
3891         hda_nid_t nid;
3892
3893         spec->multiout.num_dacs = cfg->line_outs;
3894
3895         spec->multiout.dac_nids = spec->private_dac_nids;
3896
3897         for (i = 0; i < 4; i++) {
3898                 nid = cfg->line_out_pins[i];
3899                 if (nid) {
3900                         /* config dac list */
3901                         switch (i) {
3902                         case AUTO_SEQ_FRONT:
3903                                 spec->multiout.dac_nids[i] = 0x10;
3904                                 break;
3905                         case AUTO_SEQ_CENLFE:
3906                                 spec->multiout.dac_nids[i] = 0x24;
3907                                 break;
3908                         case AUTO_SEQ_SURROUND:
3909                                 spec->multiout.dac_nids[i] = 0x11;
3910                                 break;
3911                         case AUTO_SEQ_SIDE:
3912                                 spec->multiout.dac_nids[i] = 0x25;
3913                                 break;
3914                         }
3915                 }
3916         }
3917
3918         return 0;
3919 }
3920
3921 /* add playback controls from the parsed DAC table */
3922 static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
3923                                              const struct auto_pin_cfg *cfg)
3924 {
3925         char name[32];
3926         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
3927         hda_nid_t nid_vols[] = {0x10, 0x11, 0x24, 0x25};
3928         hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x26, 0x27};
3929         hda_nid_t nid, nid_vol, nid_mute;
3930         int i, err;
3931
3932         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
3933                 nid = cfg->line_out_pins[i];
3934
3935                 if (!nid)
3936                         continue;
3937
3938                 nid_vol = nid_vols[i];
3939                 nid_mute = nid_mutes[i];
3940
3941                 if (i == AUTO_SEQ_CENLFE) {
3942                         /* Center/LFE */
3943                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3944                                               "Center Playback Volume",
3945                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
3946                                                                   HDA_OUTPUT));
3947                         if (err < 0)
3948                                 return err;
3949                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3950                                               "LFE Playback Volume",
3951                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
3952                                                                   HDA_OUTPUT));
3953                         if (err < 0)
3954                                 return err;
3955                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3956                                               "Center Playback Switch",
3957                                               HDA_COMPOSE_AMP_VAL(nid_mute,
3958                                                                   1, 0,
3959                                                                   HDA_OUTPUT));
3960                         if (err < 0)
3961                                 return err;
3962                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3963                                               "LFE Playback Switch",
3964                                               HDA_COMPOSE_AMP_VAL(nid_mute,
3965                                                                   2, 0,
3966                                                                   HDA_OUTPUT));
3967                         if (err < 0)
3968                                 return err;
3969                 } else if (i == AUTO_SEQ_FRONT) {
3970                         /* add control to mixer index 0 */
3971                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3972                                               "Master Front Playback Volume",
3973                                               HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
3974                                                                   HDA_INPUT));
3975                         if (err < 0)
3976                                 return err;
3977                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3978                                               "Master Front Playback Switch",
3979                                               HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
3980                                                                   HDA_INPUT));
3981                         if (err < 0)
3982                                 return err;
3983
3984                         /* Front */
3985                         sprintf(name, "%s Playback Volume", chname[i]);
3986                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
3987                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
3988                                                                   HDA_OUTPUT));
3989                         if (err < 0)
3990                                 return err;
3991                         sprintf(name, "%s Playback Switch", chname[i]);
3992                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
3993                                               HDA_COMPOSE_AMP_VAL(nid_mute,
3994                                                                   3, 0,
3995                                                                   HDA_OUTPUT));
3996                         if (err < 0)
3997                                 return err;
3998                 } else {
3999                         sprintf(name, "%s Playback Volume", chname[i]);
4000                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
4001                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
4002                                                                   HDA_OUTPUT));
4003                         if (err < 0)
4004                                 return err;
4005                         sprintf(name, "%s Playback Switch", chname[i]);
4006                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
4007                                               HDA_COMPOSE_AMP_VAL(nid_mute,
4008                                                                   3, 0,
4009                                                                   HDA_OUTPUT));
4010                         if (err < 0)
4011                                 return err;
4012                 }
4013         }
4014
4015         return 0;
4016 }
4017
4018 static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
4019 {
4020         int err;
4021
4022         if (!pin)
4023                 return 0;
4024
4025         spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */
4026         spec->hp_independent_mode_index = 1;
4027
4028         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4029                               "Headphone Playback Volume",
4030                               HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
4031         if (err < 0)
4032                 return err;
4033
4034         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
4035                               "Headphone Playback Switch",
4036                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4037         if (err < 0)
4038                 return err;
4039
4040         create_hp_imux(spec);
4041
4042         return 0;
4043 }
4044
4045 /* create playback/capture controls for input pins */
4046 static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec,
4047                                                 const struct auto_pin_cfg *cfg)
4048 {
4049         static char *labels[] = {
4050                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
4051         };
4052         struct hda_input_mux *imux = &spec->private_imux[0];
4053         int i, err, idx = 0;
4054
4055         /* for internal loopback recording select */
4056         imux->items[imux->num_items].label = "Stereo Mixer";
4057         imux->items[imux->num_items].index = 5;
4058         imux->num_items++;
4059
4060         for (i = 0; i < AUTO_PIN_LAST; i++) {
4061                 if (!cfg->input_pins[i])
4062                         continue;
4063
4064                 switch (cfg->input_pins[i]) {
4065                 case 0x1a: /* Mic */
4066                         idx = 2;
4067                         break;
4068
4069                 case 0x1b: /* Line In */
4070                         idx = 3;
4071                         break;
4072
4073                 case 0x1e: /* Front Mic */
4074                         idx = 4;
4075                         break;
4076
4077                 case 0x1f: /* CD */
4078                         idx = 1;
4079                         break;
4080                 }
4081                 err = via_new_analog_input(spec, labels[i], idx, 0x16);
4082                 if (err < 0)
4083                         return err;
4084                 imux->items[imux->num_items].label = labels[i];
4085                 imux->items[imux->num_items].index = idx-1;
4086                 imux->num_items++;
4087         }
4088         return 0;
4089 }
4090
4091 /* fill out digital output widgets; one for master and one for slave outputs */
4092 static void fill_dig_outs(struct hda_codec *codec)
4093 {
4094         struct via_spec *spec = codec->spec;
4095         int i;
4096
4097         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4098                 hda_nid_t nid;
4099                 int conn;
4100
4101                 nid = spec->autocfg.dig_out_pins[i];
4102                 if (!nid)
4103                         continue;
4104                 conn = snd_hda_get_connections(codec, nid, &nid, 1);
4105                 if (conn < 1)
4106                         continue;
4107                 if (!spec->multiout.dig_out_nid)
4108                         spec->multiout.dig_out_nid = nid;
4109                 else {
4110                         spec->slave_dig_outs[0] = nid;
4111                         break; /* at most two dig outs */
4112                 }
4113         }
4114 }
4115
4116 static int vt1708S_parse_auto_config(struct hda_codec *codec)
4117 {
4118         struct via_spec *spec = codec->spec;
4119         int err;
4120
4121         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
4122         if (err < 0)
4123                 return err;
4124         err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg);
4125         if (err < 0)
4126                 return err;
4127         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
4128                 return 0; /* can't find valid BIOS pin config */
4129
4130         err = vt1708S_auto_create_multi_out_ctls(spec, &spec->autocfg);
4131         if (err < 0)
4132                 return err;
4133         err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
4134         if (err < 0)
4135                 return err;
4136         err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg);
4137         if (err < 0)
4138                 return err;
4139
4140         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4141
4142         fill_dig_outs(codec);
4143
4144         if (spec->kctls.list)
4145                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4146
4147         spec->input_mux = &spec->private_imux[0];
4148
4149         if (spec->hp_mux)
4150                 via_hp_build(codec);
4151
4152         via_smart51_build(spec);
4153         return 1;
4154 }
4155
4156 #ifdef CONFIG_SND_HDA_POWER_SAVE
4157 static struct hda_amp_list vt1708S_loopbacks[] = {
4158         { 0x16, HDA_INPUT, 1 },
4159         { 0x16, HDA_INPUT, 2 },
4160         { 0x16, HDA_INPUT, 3 },
4161         { 0x16, HDA_INPUT, 4 },
4162         { } /* end */
4163 };
4164 #endif
4165
4166 static void override_mic_boost(struct hda_codec *codec, hda_nid_t pin,
4167                                int offset, int num_steps, int step_size)
4168 {
4169         snd_hda_override_amp_caps(codec, pin, HDA_INPUT,
4170                                   (offset << AC_AMPCAP_OFFSET_SHIFT) |
4171                                   (num_steps << AC_AMPCAP_NUM_STEPS_SHIFT) |
4172                                   (step_size << AC_AMPCAP_STEP_SIZE_SHIFT) |
4173                                   (0 << AC_AMPCAP_MUTE_SHIFT));
4174 }
4175
4176 static int patch_vt1708S(struct hda_codec *codec)
4177 {
4178         struct via_spec *spec;
4179         int err;
4180
4181         /* create a codec specific record */
4182         spec = via_new_spec(codec);
4183         if (spec == NULL)
4184                 return -ENOMEM;
4185
4186         /* automatic parse from the BIOS config */
4187         err = vt1708S_parse_auto_config(codec);
4188         if (err < 0) {
4189                 via_free(codec);
4190                 return err;
4191         } else if (!err) {
4192                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
4193                        "from BIOS.  Using genenic mode...\n");
4194         }
4195
4196         spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs;
4197         spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs;
4198
4199         if (codec->vendor_id == 0x11060440)
4200                 spec->stream_name_analog = "VT1818S Analog";
4201         else
4202                 spec->stream_name_analog = "VT1708S Analog";
4203         spec->stream_analog_playback = &vt1708S_pcm_analog_playback;
4204         spec->stream_analog_capture = &vt1708S_pcm_analog_capture;
4205
4206         if (codec->vendor_id == 0x11060440)
4207                 spec->stream_name_digital = "VT1818S Digital";
4208         else
4209                 spec->stream_name_digital = "VT1708S Digital";
4210         spec->stream_digital_playback = &vt1708S_pcm_digital_playback;
4211
4212         if (!spec->adc_nids && spec->input_mux) {
4213                 spec->adc_nids = vt1708S_adc_nids;
4214                 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids);
4215                 get_mux_nids(codec);
4216                 override_mic_boost(codec, 0x1a, 0, 3, 40);
4217                 override_mic_boost(codec, 0x1e, 0, 3, 40);
4218                 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
4219                 spec->num_mixers++;
4220         }
4221
4222         codec->patch_ops = via_patch_ops;
4223
4224         codec->patch_ops.init = via_auto_init;
4225         codec->patch_ops.unsol_event = via_unsol_event;
4226 #ifdef CONFIG_SND_HDA_POWER_SAVE
4227         spec->loopback.amplist = vt1708S_loopbacks;
4228 #endif
4229
4230         /* correct names for VT1708BCE */
4231         if (get_codec_type(codec) == VT1708BCE) {
4232                 kfree(codec->chip_name);
4233                 codec->chip_name = kstrdup("VT1708BCE", GFP_KERNEL);
4234                 snprintf(codec->bus->card->mixername,
4235                          sizeof(codec->bus->card->mixername),
4236                          "%s %s", codec->vendor_name, codec->chip_name);
4237                 spec->stream_name_analog = "VT1708BCE Analog";
4238                 spec->stream_name_digital = "VT1708BCE Digital";
4239         }
4240         return 0;
4241 }
4242
4243 /* Patch for VT1702 */
4244
4245 /* capture mixer elements */
4246 static struct snd_kcontrol_new vt1702_capture_mixer[] = {
4247         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT),
4248         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT),
4249         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT),
4250         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT),
4251         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT),
4252         HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT),
4253         HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0,
4254                          HDA_INPUT),
4255         {
4256                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4257                 /* The multiple "Capture Source" controls confuse alsamixer
4258                  * So call somewhat different..
4259                  */
4260                 /* .name = "Capture Source", */
4261                 .name = "Input Source",
4262                 .count = 1,
4263                 .info = via_mux_enum_info,
4264                 .get = via_mux_enum_get,
4265                 .put = via_mux_enum_put,
4266         },
4267         { } /* end */
4268 };
4269
4270 static struct hda_verb vt1702_volume_init_verbs[] = {
4271         /*
4272          * Unmute ADC0-1 and set the default input to mic-in
4273          */
4274         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4275         {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4276         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4277
4278
4279         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4280          * mixer widget
4281          */
4282         /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */
4283         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4284         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4285         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
4286         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
4287         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4288
4289         /* Setup default input of PW4 to MW0 */
4290         {0x17, AC_VERB_SET_CONNECT_SEL, 0x1},
4291         /* PW6 PW7 Output enable */
4292         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4293         {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
4294         /* mixer enable */
4295         {0x1, 0xF88, 0x3},
4296         /* GPIO 0~2 */
4297         {0x1, 0xF82, 0x3F},
4298         { }
4299 };
4300
4301 static struct hda_verb vt1702_uniwill_init_verbs[] = {
4302         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE,
4303          AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
4304         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4305         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4306         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4307         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4308         { }
4309 };
4310
4311 static struct hda_pcm_stream vt1702_pcm_analog_playback = {
4312         .substreams = 2,
4313         .channels_min = 2,
4314         .channels_max = 2,
4315         .nid = 0x10, /* NID to query formats and rates */
4316         .ops = {
4317                 .open = via_playback_pcm_open,
4318                 .prepare = via_playback_multi_pcm_prepare,
4319                 .cleanup = via_playback_multi_pcm_cleanup,
4320                 .close = via_pcm_open_close
4321         },
4322 };
4323
4324 static struct hda_pcm_stream vt1702_pcm_analog_capture = {
4325         .substreams = 3,
4326         .channels_min = 2,
4327         .channels_max = 2,
4328         .nid = 0x12, /* NID to query formats and rates */
4329         .ops = {
4330                 .open = via_pcm_open_close,
4331                 .prepare = via_capture_pcm_prepare,
4332                 .cleanup = via_capture_pcm_cleanup,
4333                 .close = via_pcm_open_close
4334         },
4335 };
4336
4337 static struct hda_pcm_stream vt1702_pcm_digital_playback = {
4338         .substreams = 2,
4339         .channels_min = 2,
4340         .channels_max = 2,
4341         /* NID is set in via_build_pcms */
4342         .ops = {
4343                 .open = via_dig_playback_pcm_open,
4344                 .close = via_dig_playback_pcm_close,
4345                 .prepare = via_dig_playback_pcm_prepare,
4346                 .cleanup = via_dig_playback_pcm_cleanup
4347         },
4348 };
4349
4350 /* fill in the dac_nids table from the parsed pin configuration */
4351 static int vt1702_auto_fill_dac_nids(struct via_spec *spec,
4352                                      const struct auto_pin_cfg *cfg)
4353 {
4354         spec->multiout.num_dacs = 1;
4355         spec->multiout.dac_nids = spec->private_dac_nids;
4356
4357         if (cfg->line_out_pins[0]) {
4358                 /* config dac list */
4359                 spec->multiout.dac_nids[0] = 0x10;
4360         }
4361
4362         return 0;
4363 }
4364
4365 /* add playback controls from the parsed DAC table */
4366 static int vt1702_auto_create_line_out_ctls(struct via_spec *spec,
4367                                              const struct auto_pin_cfg *cfg)
4368 {
4369         int err;
4370
4371         if (!cfg->line_out_pins[0])
4372                 return -1;
4373
4374         /* add control to mixer index 0 */
4375         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4376                               "Master Front Playback Volume",
4377                               HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
4378         if (err < 0)
4379                 return err;
4380         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
4381                               "Master Front Playback Switch",
4382                               HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
4383         if (err < 0)
4384                 return err;
4385
4386         /* Front */
4387         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4388                               "Front Playback Volume",
4389                               HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT));
4390         if (err < 0)
4391                 return err;
4392         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
4393                               "Front Playback Switch",
4394                               HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT));
4395         if (err < 0)
4396                 return err;
4397
4398         return 0;
4399 }
4400
4401 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
4402 {
4403         int err, i;
4404         struct hda_input_mux *imux;
4405         static const char *texts[] = { "ON", "OFF", NULL};
4406         if (!pin)
4407                 return 0;
4408         spec->multiout.hp_nid = 0x1D;
4409         spec->hp_independent_mode_index = 0;
4410
4411         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4412                               "Headphone Playback Volume",
4413                               HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT));
4414         if (err < 0)
4415                 return err;
4416
4417         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
4418                               "Headphone Playback Switch",
4419                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4420         if (err < 0)
4421                 return err;
4422
4423         imux = &spec->private_imux[1];
4424
4425         /* for hp mode select */
4426         i = 0;
4427         while (texts[i] != NULL)        {
4428                 imux->items[imux->num_items].label =  texts[i];
4429                 imux->items[imux->num_items].index = i;
4430                 imux->num_items++;
4431                 i++;
4432         }
4433
4434         spec->hp_mux = &spec->private_imux[1];
4435         return 0;
4436 }
4437
4438 /* create playback/capture controls for input pins */
4439 static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec,
4440                                                 const struct auto_pin_cfg *cfg)
4441 {
4442         static char *labels[] = {
4443                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
4444         };
4445         struct hda_input_mux *imux = &spec->private_imux[0];
4446         int i, err, idx = 0;
4447
4448         /* for internal loopback recording select */
4449         imux->items[imux->num_items].label = "Stereo Mixer";
4450         imux->items[imux->num_items].index = 3;
4451         imux->num_items++;
4452
4453         for (i = 0; i < AUTO_PIN_LAST; i++) {
4454                 if (!cfg->input_pins[i])
4455                         continue;
4456
4457                 switch (cfg->input_pins[i]) {
4458                 case 0x14: /* Mic */
4459                         idx = 1;
4460                         break;
4461
4462                 case 0x15: /* Line In */
4463                         idx = 2;
4464                         break;
4465
4466                 case 0x18: /* Front Mic */
4467                         idx = 3;
4468                         break;
4469                 }
4470                 err = via_new_analog_input(spec, labels[i], idx, 0x1A);
4471                 if (err < 0)
4472                         return err;
4473                 imux->items[imux->num_items].label = labels[i];
4474                 imux->items[imux->num_items].index = idx-1;
4475                 imux->num_items++;
4476         }
4477         return 0;
4478 }
4479
4480 static int vt1702_parse_auto_config(struct hda_codec *codec)
4481 {
4482         struct via_spec *spec = codec->spec;
4483         int err;
4484
4485         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
4486         if (err < 0)
4487                 return err;
4488         err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg);
4489         if (err < 0)
4490                 return err;
4491         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
4492                 return 0; /* can't find valid BIOS pin config */
4493
4494         err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg);
4495         if (err < 0)
4496                 return err;
4497         err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
4498         if (err < 0)
4499                 return err;
4500         /* limit AA path volume to 0 dB */
4501         snd_hda_override_amp_caps(codec, 0x1A, HDA_INPUT,
4502                                   (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
4503                                   (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4504                                   (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4505                                   (1 << AC_AMPCAP_MUTE_SHIFT));
4506         err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg);
4507         if (err < 0)
4508                 return err;
4509
4510         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4511
4512         fill_dig_outs(codec);
4513
4514         if (spec->kctls.list)
4515                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4516
4517         spec->input_mux = &spec->private_imux[0];
4518
4519         if (spec->hp_mux)
4520                 via_hp_build(codec);
4521
4522         return 1;
4523 }
4524
4525 #ifdef CONFIG_SND_HDA_POWER_SAVE
4526 static struct hda_amp_list vt1702_loopbacks[] = {
4527         { 0x1A, HDA_INPUT, 1 },
4528         { 0x1A, HDA_INPUT, 2 },
4529         { 0x1A, HDA_INPUT, 3 },
4530         { 0x1A, HDA_INPUT, 4 },
4531         { } /* end */
4532 };
4533 #endif
4534
4535 static int patch_vt1702(struct hda_codec *codec)
4536 {
4537         struct via_spec *spec;
4538         int err;
4539
4540         /* create a codec specific record */
4541         spec = via_new_spec(codec);
4542         if (spec == NULL)
4543                 return -ENOMEM;
4544
4545         /* automatic parse from the BIOS config */
4546         err = vt1702_parse_auto_config(codec);
4547         if (err < 0) {
4548                 via_free(codec);
4549                 return err;
4550         } else if (!err) {
4551                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
4552                        "from BIOS.  Using genenic mode...\n");
4553         }
4554
4555         spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs;
4556         spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs;
4557
4558         spec->stream_name_analog = "VT1702 Analog";
4559         spec->stream_analog_playback = &vt1702_pcm_analog_playback;
4560         spec->stream_analog_capture = &vt1702_pcm_analog_capture;
4561
4562         spec->stream_name_digital = "VT1702 Digital";
4563         spec->stream_digital_playback = &vt1702_pcm_digital_playback;
4564
4565         if (!spec->adc_nids && spec->input_mux) {
4566                 spec->adc_nids = vt1702_adc_nids;
4567                 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids);
4568                 get_mux_nids(codec);
4569                 spec->mixers[spec->num_mixers] = vt1702_capture_mixer;
4570                 spec->num_mixers++;
4571         }
4572
4573         codec->patch_ops = via_patch_ops;
4574
4575         codec->patch_ops.init = via_auto_init;
4576         codec->patch_ops.unsol_event = via_unsol_event;
4577 #ifdef CONFIG_SND_HDA_POWER_SAVE
4578         spec->loopback.amplist = vt1702_loopbacks;
4579 #endif
4580
4581         return 0;
4582 }
4583
4584 /* Patch for VT1718S */
4585
4586 /* capture mixer elements */
4587 static struct snd_kcontrol_new vt1718S_capture_mixer[] = {
4588         HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
4589         HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
4590         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
4591         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
4592         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
4593         HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0,
4594                          HDA_INPUT),
4595         {
4596                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4597                 /* The multiple "Capture Source" controls confuse alsamixer
4598                  * So call somewhat different..
4599                  */
4600                 .name = "Input Source",
4601                 .count = 2,
4602                 .info = via_mux_enum_info,
4603                 .get = via_mux_enum_get,
4604                 .put = via_mux_enum_put,
4605         },
4606         { } /* end */
4607 };
4608
4609 static struct hda_verb vt1718S_volume_init_verbs[] = {
4610         /*
4611          * Unmute ADC0-1 and set the default input to mic-in
4612          */
4613         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4614         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4615
4616
4617         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
4618          * mixer widget
4619          */
4620         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
4621         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4622         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4623         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4624         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4625         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
4626
4627         /* Setup default input of Front HP to MW9 */
4628         {0x28, AC_VERB_SET_CONNECT_SEL, 0x1},
4629         /* PW9 PW10 Output enable */
4630         {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
4631         {0x2e, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
4632         /* PW11 Input enable */
4633         {0x2f, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_IN_EN},
4634         /* Enable Boost Volume backdoor */
4635         {0x1, 0xf88, 0x8},
4636         /* MW0/1/2/3/4: un-mute index 0 (AOWx), mute index 1 (MW9) */
4637         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4638         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4639         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4640         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4641         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4642         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4643         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4644         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4645         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4646         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4647         /* set MUX1 = 2 (AOW4), MUX2 = 1 (AOW3) */
4648         {0x34, AC_VERB_SET_CONNECT_SEL, 0x2},
4649         {0x35, AC_VERB_SET_CONNECT_SEL, 0x1},
4650         /* Unmute MW4's index 0 */
4651         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4652         { }
4653 };
4654
4655
4656 static struct hda_verb vt1718S_uniwill_init_verbs[] = {
4657         {0x28, AC_VERB_SET_UNSOLICITED_ENABLE,
4658          AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
4659         {0x24, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4660         {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4661         {0x26, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4662         {0x27, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4663         {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4664         {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4665         {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
4666         { }
4667 };
4668
4669 static struct hda_pcm_stream vt1718S_pcm_analog_playback = {
4670         .substreams = 2,
4671         .channels_min = 2,
4672         .channels_max = 10,
4673         .nid = 0x8, /* NID to query formats and rates */
4674         .ops = {
4675                 .open = via_playback_pcm_open,
4676                 .prepare = via_playback_multi_pcm_prepare,
4677                 .cleanup = via_playback_multi_pcm_cleanup,
4678                 .close = via_pcm_open_close,
4679         },
4680 };
4681
4682 static struct hda_pcm_stream vt1718S_pcm_analog_capture = {
4683         .substreams = 2,
4684         .channels_min = 2,
4685         .channels_max = 2,
4686         .nid = 0x10, /* NID to query formats and rates */
4687         .ops = {
4688                 .open = via_pcm_open_close,
4689                 .prepare = via_capture_pcm_prepare,
4690                 .cleanup = via_capture_pcm_cleanup,
4691                 .close = via_pcm_open_close,
4692         },
4693 };
4694
4695 static struct hda_pcm_stream vt1718S_pcm_digital_playback = {
4696         .substreams = 2,
4697         .channels_min = 2,
4698         .channels_max = 2,
4699         /* NID is set in via_build_pcms */
4700         .ops = {
4701                 .open = via_dig_playback_pcm_open,
4702                 .close = via_dig_playback_pcm_close,
4703                 .prepare = via_dig_playback_pcm_prepare,
4704                 .cleanup = via_dig_playback_pcm_cleanup
4705         },
4706 };
4707
4708 static struct hda_pcm_stream vt1718S_pcm_digital_capture = {
4709         .substreams = 1,
4710         .channels_min = 2,
4711         .channels_max = 2,
4712 };
4713
4714 /* fill in the dac_nids table from the parsed pin configuration */
4715 static int vt1718S_auto_fill_dac_nids(struct via_spec *spec,
4716                                      const struct auto_pin_cfg *cfg)
4717 {
4718         int i;
4719         hda_nid_t nid;
4720
4721         spec->multiout.num_dacs = cfg->line_outs;
4722
4723         spec->multiout.dac_nids = spec->private_dac_nids;
4724
4725         for (i = 0; i < 4; i++) {
4726                 nid = cfg->line_out_pins[i];
4727                 if (nid) {
4728                         /* config dac list */
4729                         switch (i) {
4730                         case AUTO_SEQ_FRONT:
4731                                 spec->multiout.dac_nids[i] = 0x8;
4732                                 break;
4733                         case AUTO_SEQ_CENLFE:
4734                                 spec->multiout.dac_nids[i] = 0xa;
4735                                 break;
4736                         case AUTO_SEQ_SURROUND:
4737                                 spec->multiout.dac_nids[i] = 0x9;
4738                                 break;
4739                         case AUTO_SEQ_SIDE:
4740                                 spec->multiout.dac_nids[i] = 0xb;
4741                                 break;
4742                         }
4743                 }
4744         }
4745
4746         return 0;
4747 }
4748
4749 /* add playback controls from the parsed DAC table */
4750 static int vt1718S_auto_create_multi_out_ctls(struct via_spec *spec,
4751                                              const struct auto_pin_cfg *cfg)
4752 {
4753         char name[32];
4754         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
4755         hda_nid_t nid_vols[] = {0x8, 0x9, 0xa, 0xb};
4756         hda_nid_t nid_mutes[] = {0x24, 0x25, 0x26, 0x27};
4757         hda_nid_t nid, nid_vol, nid_mute = 0;
4758         int i, err;
4759
4760         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
4761                 nid = cfg->line_out_pins[i];
4762
4763                 if (!nid)
4764                         continue;
4765                 nid_vol = nid_vols[i];
4766                 nid_mute = nid_mutes[i];
4767
4768                 if (i == AUTO_SEQ_CENLFE) {
4769                         /* Center/LFE */
4770                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4771                                               "Center Playback Volume",
4772                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
4773                                                                   HDA_OUTPUT));
4774                         if (err < 0)
4775                                 return err;
4776                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4777                                               "LFE Playback Volume",
4778                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
4779                                                                   HDA_OUTPUT));
4780                         if (err < 0)
4781                                 return err;
4782                         err = via_add_control(
4783                                 spec, VIA_CTL_WIDGET_MUTE,
4784                                 "Center Playback Switch",
4785                                 HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0,
4786                                                     HDA_OUTPUT));
4787                         if (err < 0)
4788                                 return err;
4789                         err = via_add_control(
4790                                 spec, VIA_CTL_WIDGET_MUTE,
4791                                 "LFE Playback Switch",
4792                                 HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0,
4793                                                     HDA_OUTPUT));
4794                         if (err < 0)
4795                                 return err;
4796                 } else if (i == AUTO_SEQ_FRONT) {
4797                         /* Front */
4798                         sprintf(name, "%s Playback Volume", chname[i]);
4799                         err = via_add_control(
4800                                 spec, VIA_CTL_WIDGET_VOL, name,
4801                                 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
4802                         if (err < 0)
4803                                 return err;
4804                         sprintf(name, "%s Playback Switch", chname[i]);
4805                         err = via_add_control(
4806                                 spec, VIA_CTL_WIDGET_MUTE, name,
4807                                 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
4808                                                     HDA_OUTPUT));
4809                         if (err < 0)
4810                                 return err;
4811                 } else {
4812                         sprintf(name, "%s Playback Volume", chname[i]);
4813                         err = via_add_control(
4814                                 spec, VIA_CTL_WIDGET_VOL, name,
4815                                 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
4816                         if (err < 0)
4817                                 return err;
4818                         sprintf(name, "%s Playback Switch", chname[i]);
4819                         err = via_add_control(
4820                                 spec, VIA_CTL_WIDGET_MUTE, name,
4821                                 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
4822                                                     HDA_OUTPUT));
4823                         if (err < 0)
4824                                 return err;
4825                 }
4826         }
4827         return 0;
4828 }
4829
4830 static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
4831 {
4832         int err;
4833
4834         if (!pin)
4835                 return 0;
4836
4837         spec->multiout.hp_nid = 0xc; /* AOW4 */
4838         spec->hp_independent_mode_index = 1;
4839
4840         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
4841                               "Headphone Playback Volume",
4842                               HDA_COMPOSE_AMP_VAL(0xc, 3, 0, HDA_OUTPUT));
4843         if (err < 0)
4844                 return err;
4845
4846         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
4847                               "Headphone Playback Switch",
4848                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4849         if (err < 0)
4850                 return err;
4851
4852         create_hp_imux(spec);
4853         return 0;
4854 }
4855
4856 /* create playback/capture controls for input pins */
4857 static int vt1718S_auto_create_analog_input_ctls(struct via_spec *spec,
4858                                                 const struct auto_pin_cfg *cfg)
4859 {
4860         static char *labels[] = {
4861                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
4862         };
4863         struct hda_input_mux *imux = &spec->private_imux[0];
4864         int i, err, idx = 0;
4865
4866         /* for internal loopback recording select */
4867         imux->items[imux->num_items].label = "Stereo Mixer";
4868         imux->items[imux->num_items].index = 5;
4869         imux->num_items++;
4870
4871         for (i = 0; i < AUTO_PIN_LAST; i++) {
4872                 if (!cfg->input_pins[i])
4873                         continue;
4874
4875                 switch (cfg->input_pins[i]) {
4876                 case 0x2b: /* Mic */
4877                         idx = 1;
4878                         break;
4879
4880                 case 0x2a: /* Line In */
4881                         idx = 2;
4882                         break;
4883
4884                 case 0x29: /* Front Mic */
4885                         idx = 3;
4886                         break;
4887
4888                 case 0x2c: /* CD */
4889                         idx = 0;
4890                         break;
4891                 }
4892                 err = via_new_analog_input(spec, labels[i], idx, 0x21);
4893                 if (err < 0)
4894                         return err;
4895                 imux->items[imux->num_items].label = labels[i];
4896                 imux->items[imux->num_items].index = idx;
4897                 imux->num_items++;
4898         }
4899         return 0;
4900 }
4901
4902 static int vt1718S_parse_auto_config(struct hda_codec *codec)
4903 {
4904         struct via_spec *spec = codec->spec;
4905         int err;
4906
4907         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
4908
4909         if (err < 0)
4910                 return err;
4911         err = vt1718S_auto_fill_dac_nids(spec, &spec->autocfg);
4912         if (err < 0)
4913                 return err;
4914         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
4915                 return 0; /* can't find valid BIOS pin config */
4916
4917         err = vt1718S_auto_create_multi_out_ctls(spec, &spec->autocfg);
4918         if (err < 0)
4919                 return err;
4920         err = vt1718S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
4921         if (err < 0)
4922                 return err;
4923         err = vt1718S_auto_create_analog_input_ctls(spec, &spec->autocfg);
4924         if (err < 0)
4925                 return err;
4926
4927         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4928
4929         fill_dig_outs(codec);
4930
4931         if (spec->autocfg.dig_in_pin && codec->vendor_id == 0x11060428)
4932                 spec->dig_in_nid = 0x13;
4933
4934         if (spec->kctls.list)
4935                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
4936
4937         spec->input_mux = &spec->private_imux[0];
4938
4939         if (spec->hp_mux)
4940                 via_hp_build(codec);
4941
4942         via_smart51_build(spec);
4943
4944         return 1;
4945 }
4946
4947 #ifdef CONFIG_SND_HDA_POWER_SAVE
4948 static struct hda_amp_list vt1718S_loopbacks[] = {
4949         { 0x21, HDA_INPUT, 1 },
4950         { 0x21, HDA_INPUT, 2 },
4951         { 0x21, HDA_INPUT, 3 },
4952         { 0x21, HDA_INPUT, 4 },
4953         { } /* end */
4954 };
4955 #endif
4956
4957 static int patch_vt1718S(struct hda_codec *codec)
4958 {
4959         struct via_spec *spec;
4960         int err;
4961
4962         /* create a codec specific record */
4963         spec = via_new_spec(codec);
4964         if (spec == NULL)
4965                 return -ENOMEM;
4966
4967         /* automatic parse from the BIOS config */
4968         err = vt1718S_parse_auto_config(codec);
4969         if (err < 0) {
4970                 via_free(codec);
4971                 return err;
4972         } else if (!err) {
4973                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
4974                        "from BIOS.  Using genenic mode...\n");
4975         }
4976
4977         spec->init_verbs[spec->num_iverbs++] = vt1718S_volume_init_verbs;
4978         spec->init_verbs[spec->num_iverbs++] = vt1718S_uniwill_init_verbs;
4979
4980         if (codec->vendor_id == 0x11060441)
4981                 spec->stream_name_analog = "VT2020 Analog";
4982         else if (codec->vendor_id == 0x11064441)
4983                 spec->stream_name_analog = "VT1828S Analog";
4984         else
4985                 spec->stream_name_analog = "VT1718S Analog";
4986         spec->stream_analog_playback = &vt1718S_pcm_analog_playback;
4987         spec->stream_analog_capture = &vt1718S_pcm_analog_capture;
4988
4989         if (codec->vendor_id == 0x11060441)
4990                 spec->stream_name_digital = "VT2020 Digital";
4991         else if (codec->vendor_id == 0x11064441)
4992                 spec->stream_name_digital = "VT1828S Digital";
4993         else
4994                 spec->stream_name_digital = "VT1718S Digital";
4995         spec->stream_digital_playback = &vt1718S_pcm_digital_playback;
4996         if (codec->vendor_id == 0x11060428 || codec->vendor_id == 0x11060441)
4997                 spec->stream_digital_capture = &vt1718S_pcm_digital_capture;
4998
4999         if (!spec->adc_nids && spec->input_mux) {
5000                 spec->adc_nids = vt1718S_adc_nids;
5001                 spec->num_adc_nids = ARRAY_SIZE(vt1718S_adc_nids);
5002                 get_mux_nids(codec);
5003                 override_mic_boost(codec, 0x2b, 0, 3, 40);
5004                 override_mic_boost(codec, 0x29, 0, 3, 40);
5005                 spec->mixers[spec->num_mixers] = vt1718S_capture_mixer;
5006                 spec->num_mixers++;
5007         }
5008
5009         codec->patch_ops = via_patch_ops;
5010
5011         codec->patch_ops.init = via_auto_init;
5012         codec->patch_ops.unsol_event = via_unsol_event;
5013
5014 #ifdef CONFIG_SND_HDA_POWER_SAVE
5015         spec->loopback.amplist = vt1718S_loopbacks;
5016 #endif
5017
5018         return 0;
5019 }
5020
5021 /* Patch for VT1716S */
5022
5023 static int vt1716s_dmic_info(struct snd_kcontrol *kcontrol,
5024                             struct snd_ctl_elem_info *uinfo)
5025 {
5026         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
5027         uinfo->count = 1;
5028         uinfo->value.integer.min = 0;
5029         uinfo->value.integer.max = 1;
5030         return 0;
5031 }
5032
5033 static int vt1716s_dmic_get(struct snd_kcontrol *kcontrol,
5034                            struct snd_ctl_elem_value *ucontrol)
5035 {
5036         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5037         int index = 0;
5038
5039         index = snd_hda_codec_read(codec, 0x26, 0,
5040                                                AC_VERB_GET_CONNECT_SEL, 0);
5041         if (index != -1)
5042                 *ucontrol->value.integer.value = index;
5043
5044         return 0;
5045 }
5046
5047 static int vt1716s_dmic_put(struct snd_kcontrol *kcontrol,
5048                            struct snd_ctl_elem_value *ucontrol)
5049 {
5050         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5051         struct via_spec *spec = codec->spec;
5052         int index = *ucontrol->value.integer.value;
5053
5054         snd_hda_codec_write(codec, 0x26, 0,
5055                                                AC_VERB_SET_CONNECT_SEL, index);
5056         spec->dmic_enabled = index;
5057         set_jack_power_state(codec);
5058
5059         return 1;
5060 }
5061
5062 /* capture mixer elements */
5063 static struct snd_kcontrol_new vt1716S_capture_mixer[] = {
5064         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
5065         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
5066         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
5067         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
5068         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x1A, 0x0, HDA_INPUT),
5069         HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x1E, 0x0,
5070                          HDA_INPUT),
5071         {
5072                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5073                 .name = "Input Source",
5074                 .count = 1,
5075                 .info = via_mux_enum_info,
5076                 .get = via_mux_enum_get,
5077                 .put = via_mux_enum_put,
5078         },
5079         { } /* end */
5080 };
5081
5082 static struct snd_kcontrol_new vt1716s_dmic_mixer[] = {
5083         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x22, 0x0, HDA_INPUT),
5084         {
5085          .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5086          .name = "Digital Mic Capture Switch",
5087          .subdevice = HDA_SUBDEV_NID_FLAG | 0x26,
5088          .count = 1,
5089          .info = vt1716s_dmic_info,
5090          .get = vt1716s_dmic_get,
5091          .put = vt1716s_dmic_put,
5092          },
5093         {}                      /* end */
5094 };
5095
5096
5097 /* mono-out mixer elements */
5098 static struct snd_kcontrol_new vt1716S_mono_out_mixer[] = {
5099         HDA_CODEC_MUTE("Mono Playback Switch", 0x2a, 0x0, HDA_OUTPUT),
5100         { } /* end */
5101 };
5102
5103 static struct hda_verb vt1716S_volume_init_verbs[] = {
5104         /*
5105          * Unmute ADC0-1 and set the default input to mic-in
5106          */
5107         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5108         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5109
5110
5111         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5112          * mixer widget
5113          */
5114         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
5115         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5116         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5117         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5118         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5119         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5120
5121         /* MUX Indices: Stereo Mixer = 5 */
5122         {0x17, AC_VERB_SET_CONNECT_SEL, 0x5},
5123
5124         /* Setup default input of PW4 to MW0 */
5125         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
5126
5127         /* Setup default input of SW1 as MW0 */
5128         {0x18, AC_VERB_SET_CONNECT_SEL, 0x1},
5129
5130         /* Setup default input of SW4 as AOW0 */
5131         {0x28, AC_VERB_SET_CONNECT_SEL, 0x1},
5132
5133         /* PW9 PW10 Output enable */
5134         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5135         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5136
5137         /* Unmute SW1, PW12 */
5138         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5139         {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5140         /* PW12 Output enable */
5141         {0x2a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5142         /* Enable Boost Volume backdoor */
5143         {0x1, 0xf8a, 0x80},
5144         /* don't bybass mixer */
5145         {0x1, 0xf88, 0xc0},
5146         /* Enable mono output */
5147         {0x1, 0xf90, 0x08},
5148         { }
5149 };
5150
5151
5152 static struct hda_verb vt1716S_uniwill_init_verbs[] = {
5153         {0x1d, AC_VERB_SET_UNSOLICITED_ENABLE,
5154          AC_USRSP_EN | VIA_HP_EVENT | VIA_JACK_EVENT},
5155         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5156         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5157         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5158         {0x1c, AC_VERB_SET_UNSOLICITED_ENABLE,
5159          AC_USRSP_EN | VIA_MONO_EVENT | VIA_JACK_EVENT},
5160         {0x1e, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5161         {0x23, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5162         { }
5163 };
5164
5165 static struct hda_pcm_stream vt1716S_pcm_analog_playback = {
5166         .substreams = 2,
5167         .channels_min = 2,
5168         .channels_max = 6,
5169         .nid = 0x10, /* NID to query formats and rates */
5170         .ops = {
5171                 .open = via_playback_pcm_open,
5172                 .prepare = via_playback_multi_pcm_prepare,
5173                 .cleanup = via_playback_multi_pcm_cleanup,
5174                 .close = via_pcm_open_close,
5175         },
5176 };
5177
5178 static struct hda_pcm_stream vt1716S_pcm_analog_capture = {
5179         .substreams = 2,
5180         .channels_min = 2,
5181         .channels_max = 2,
5182         .nid = 0x13, /* NID to query formats and rates */
5183         .ops = {
5184                 .open = via_pcm_open_close,
5185                 .prepare = via_capture_pcm_prepare,
5186                 .cleanup = via_capture_pcm_cleanup,
5187                 .close = via_pcm_open_close,
5188         },
5189 };
5190
5191 static struct hda_pcm_stream vt1716S_pcm_digital_playback = {
5192         .substreams = 2,
5193         .channels_min = 2,
5194         .channels_max = 2,
5195         /* NID is set in via_build_pcms */
5196         .ops = {
5197                 .open = via_dig_playback_pcm_open,
5198                 .close = via_dig_playback_pcm_close,
5199                 .prepare = via_dig_playback_pcm_prepare,
5200                 .cleanup = via_dig_playback_pcm_cleanup
5201         },
5202 };
5203
5204 /* fill in the dac_nids table from the parsed pin configuration */
5205 static int vt1716S_auto_fill_dac_nids(struct via_spec *spec,
5206                                       const struct auto_pin_cfg *cfg)
5207 {       int i;
5208         hda_nid_t nid;
5209
5210         spec->multiout.num_dacs = cfg->line_outs;
5211
5212         spec->multiout.dac_nids = spec->private_dac_nids;
5213
5214         for (i = 0; i < 3; i++) {
5215                 nid = cfg->line_out_pins[i];
5216                 if (nid) {
5217                         /* config dac list */
5218                         switch (i) {
5219                         case AUTO_SEQ_FRONT:
5220                                 spec->multiout.dac_nids[i] = 0x10;
5221                                 break;
5222                         case AUTO_SEQ_CENLFE:
5223                                 spec->multiout.dac_nids[i] = 0x25;
5224                                 break;
5225                         case AUTO_SEQ_SURROUND:
5226                                 spec->multiout.dac_nids[i] = 0x11;
5227                                 break;
5228                         }
5229                 }
5230         }
5231
5232         return 0;
5233 }
5234
5235 /* add playback controls from the parsed DAC table */
5236 static int vt1716S_auto_create_multi_out_ctls(struct via_spec *spec,
5237                                               const struct auto_pin_cfg *cfg)
5238 {
5239         char name[32];
5240         static const char *chname[3] = { "Front", "Surround", "C/LFE" };
5241         hda_nid_t nid_vols[] = {0x10, 0x11, 0x25};
5242         hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x27};
5243         hda_nid_t nid, nid_vol, nid_mute;
5244         int i, err;
5245
5246         for (i = 0; i <= AUTO_SEQ_CENLFE; i++) {
5247                 nid = cfg->line_out_pins[i];
5248
5249                 if (!nid)
5250                         continue;
5251
5252                 nid_vol = nid_vols[i];
5253                 nid_mute = nid_mutes[i];
5254
5255                 if (i == AUTO_SEQ_CENLFE) {
5256                         err = via_add_control(
5257                                 spec, VIA_CTL_WIDGET_VOL,
5258                                 "Center Playback Volume",
5259                                 HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0, HDA_OUTPUT));
5260                         if (err < 0)
5261                                 return err;
5262                         err = via_add_control(
5263                                 spec, VIA_CTL_WIDGET_VOL,
5264                                 "LFE Playback Volume",
5265                                 HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT));
5266                         if (err < 0)
5267                                 return err;
5268                         err = via_add_control(
5269                                 spec, VIA_CTL_WIDGET_MUTE,
5270                                 "Center Playback Switch",
5271                                 HDA_COMPOSE_AMP_VAL(nid_mute, 1, 0,
5272                                                     HDA_OUTPUT));
5273                         if (err < 0)
5274                                 return err;
5275                         err = via_add_control(
5276                                 spec, VIA_CTL_WIDGET_MUTE,
5277                                 "LFE Playback Switch",
5278                                 HDA_COMPOSE_AMP_VAL(nid_mute, 2, 0,
5279                                                     HDA_OUTPUT));
5280                         if (err < 0)
5281                                 return err;
5282                 } else if (i == AUTO_SEQ_FRONT) {
5283
5284                         err = via_add_control(
5285                                 spec, VIA_CTL_WIDGET_VOL,
5286                                 "Master Front Playback Volume",
5287                                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT));
5288                         if (err < 0)
5289                                 return err;
5290                         err = via_add_control(
5291                                 spec, VIA_CTL_WIDGET_MUTE,
5292                                 "Master Front Playback Switch",
5293                                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_INPUT));
5294                         if (err < 0)
5295                                 return err;
5296
5297                         sprintf(name, "%s Playback Volume", chname[i]);
5298                         err = via_add_control(
5299                                 spec, VIA_CTL_WIDGET_VOL, name,
5300                                 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
5301                         if (err < 0)
5302                                 return err;
5303                         sprintf(name, "%s Playback Switch", chname[i]);
5304                         err = via_add_control(
5305                                 spec, VIA_CTL_WIDGET_MUTE, name,
5306                                 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
5307                                                     HDA_OUTPUT));
5308                         if (err < 0)
5309                                 return err;
5310                 } else {
5311                         sprintf(name, "%s Playback Volume", chname[i]);
5312                         err = via_add_control(
5313                                 spec, VIA_CTL_WIDGET_VOL, name,
5314                                 HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT));
5315                         if (err < 0)
5316                                 return err;
5317                         sprintf(name, "%s Playback Switch", chname[i]);
5318                         err = via_add_control(
5319                                 spec, VIA_CTL_WIDGET_MUTE, name,
5320                                 HDA_COMPOSE_AMP_VAL(nid_mute, 3, 0,
5321                                                     HDA_OUTPUT));
5322                         if (err < 0)
5323                                 return err;
5324                 }
5325         }
5326         return 0;
5327 }
5328
5329 static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
5330 {
5331         int err;
5332
5333         if (!pin)
5334                 return 0;
5335
5336         spec->multiout.hp_nid = 0x25; /* AOW3 */
5337         spec->hp_independent_mode_index = 1;
5338
5339         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
5340                               "Headphone Playback Volume",
5341                               HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
5342         if (err < 0)
5343                 return err;
5344
5345         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
5346                               "Headphone Playback Switch",
5347                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
5348         if (err < 0)
5349                 return err;
5350
5351         create_hp_imux(spec);
5352         return 0;
5353 }
5354
5355 /* create playback/capture controls for input pins */
5356 static int vt1716S_auto_create_analog_input_ctls(struct via_spec *spec,
5357                                                 const struct auto_pin_cfg *cfg)
5358 {
5359         static char *labels[] = {
5360                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
5361         };
5362         struct hda_input_mux *imux = &spec->private_imux[0];
5363         int i, err, idx = 0;
5364
5365         /* for internal loopback recording select */
5366         imux->items[imux->num_items].label = "Stereo Mixer";
5367         imux->items[imux->num_items].index = 5;
5368         imux->num_items++;
5369
5370         for (i = 0; i < AUTO_PIN_LAST; i++) {
5371                 if (!cfg->input_pins[i])
5372                         continue;
5373
5374                 switch (cfg->input_pins[i]) {
5375                 case 0x1a: /* Mic */
5376                         idx = 2;
5377                         break;
5378
5379                 case 0x1b: /* Line In */
5380                         idx = 3;
5381                         break;
5382
5383                 case 0x1e: /* Front Mic */
5384                         idx = 4;
5385                         break;
5386
5387                 case 0x1f: /* CD */
5388                         idx = 1;
5389                         break;
5390                 }
5391                 err = via_new_analog_input(spec, labels[i], idx, 0x16);
5392                 if (err < 0)
5393                         return err;
5394                 imux->items[imux->num_items].label = labels[i];
5395                 imux->items[imux->num_items].index = idx-1;
5396                 imux->num_items++;
5397         }
5398         return 0;
5399 }
5400
5401 static int vt1716S_parse_auto_config(struct hda_codec *codec)
5402 {
5403         struct via_spec *spec = codec->spec;
5404         int err;
5405
5406         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
5407         if (err < 0)
5408                 return err;
5409         err = vt1716S_auto_fill_dac_nids(spec, &spec->autocfg);
5410         if (err < 0)
5411                 return err;
5412         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
5413                 return 0; /* can't find valid BIOS pin config */
5414
5415         err = vt1716S_auto_create_multi_out_ctls(spec, &spec->autocfg);
5416         if (err < 0)
5417                 return err;
5418         err = vt1716S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
5419         if (err < 0)
5420                 return err;
5421         err = vt1716S_auto_create_analog_input_ctls(spec, &spec->autocfg);
5422         if (err < 0)
5423                 return err;
5424
5425         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5426
5427         fill_dig_outs(codec);
5428
5429         if (spec->kctls.list)
5430                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
5431
5432         spec->input_mux = &spec->private_imux[0];
5433
5434         if (spec->hp_mux)
5435                 via_hp_build(codec);
5436
5437         via_smart51_build(spec);
5438
5439         return 1;
5440 }
5441
5442 #ifdef CONFIG_SND_HDA_POWER_SAVE
5443 static struct hda_amp_list vt1716S_loopbacks[] = {
5444         { 0x16, HDA_INPUT, 1 },
5445         { 0x16, HDA_INPUT, 2 },
5446         { 0x16, HDA_INPUT, 3 },
5447         { 0x16, HDA_INPUT, 4 },
5448         { } /* end */
5449 };
5450 #endif
5451
5452 static int patch_vt1716S(struct hda_codec *codec)
5453 {
5454         struct via_spec *spec;
5455         int err;
5456
5457         /* create a codec specific record */
5458         spec = via_new_spec(codec);
5459         if (spec == NULL)
5460                 return -ENOMEM;
5461
5462         /* automatic parse from the BIOS config */
5463         err = vt1716S_parse_auto_config(codec);
5464         if (err < 0) {
5465                 via_free(codec);
5466                 return err;
5467         } else if (!err) {
5468                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
5469                        "from BIOS.  Using genenic mode...\n");
5470         }
5471
5472         spec->init_verbs[spec->num_iverbs++]  = vt1716S_volume_init_verbs;
5473         spec->init_verbs[spec->num_iverbs++] = vt1716S_uniwill_init_verbs;
5474
5475         spec->stream_name_analog = "VT1716S Analog";
5476         spec->stream_analog_playback = &vt1716S_pcm_analog_playback;
5477         spec->stream_analog_capture = &vt1716S_pcm_analog_capture;
5478
5479         spec->stream_name_digital = "VT1716S Digital";
5480         spec->stream_digital_playback = &vt1716S_pcm_digital_playback;
5481
5482         if (!spec->adc_nids && spec->input_mux) {
5483                 spec->adc_nids = vt1716S_adc_nids;
5484                 spec->num_adc_nids = ARRAY_SIZE(vt1716S_adc_nids);
5485                 get_mux_nids(codec);
5486                 override_mic_boost(codec, 0x1a, 0, 3, 40);
5487                 override_mic_boost(codec, 0x1e, 0, 3, 40);
5488                 spec->mixers[spec->num_mixers] = vt1716S_capture_mixer;
5489                 spec->num_mixers++;
5490         }
5491
5492         spec->mixers[spec->num_mixers] = vt1716s_dmic_mixer;
5493         spec->num_mixers++;
5494
5495         spec->mixers[spec->num_mixers++] = vt1716S_mono_out_mixer;
5496
5497         codec->patch_ops = via_patch_ops;
5498
5499         codec->patch_ops.init = via_auto_init;
5500         codec->patch_ops.unsol_event = via_unsol_event;
5501
5502 #ifdef CONFIG_SND_HDA_POWER_SAVE
5503         spec->loopback.amplist = vt1716S_loopbacks;
5504 #endif
5505
5506         return 0;
5507 }
5508
5509 /* for vt2002P */
5510
5511 /* capture mixer elements */
5512 static struct snd_kcontrol_new vt2002P_capture_mixer[] = {
5513         HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
5514         HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
5515         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
5516         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
5517         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
5518         HDA_CODEC_VOLUME("Front Mic Boost Capture Volume", 0x29, 0x0,
5519                          HDA_INPUT),
5520         {
5521                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5522                 /* The multiple "Capture Source" controls confuse alsamixer
5523                  * So call somewhat different..
5524                  */
5525                 /* .name = "Capture Source", */
5526                 .name = "Input Source",
5527                 .count = 2,
5528                 .info = via_mux_enum_info,
5529                 .get = via_mux_enum_get,
5530                 .put = via_mux_enum_put,
5531         },
5532         { } /* end */
5533 };
5534
5535 static struct hda_verb vt2002P_volume_init_verbs[] = {
5536         /*
5537          * Unmute ADC0-1 and set the default input to mic-in
5538          */
5539         {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5540         {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5541
5542
5543         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5544          * mixer widget
5545          */
5546         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
5547         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5548         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5549         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5550         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5551         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5552
5553         /* MUX Indices: Mic = 0 */
5554         {0x1e, AC_VERB_SET_CONNECT_SEL, 0},
5555         {0x1f, AC_VERB_SET_CONNECT_SEL, 0},
5556
5557         /* PW9 Output enable */
5558         {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
5559
5560         /* Enable Boost Volume backdoor */
5561         {0x1, 0xfb9, 0x24},
5562
5563         /* MW0/1/4/8: un-mute index 0 (MUXx), un-mute index 1 (MW9) */
5564         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5565         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5566         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5567         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5568         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5569         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5570         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5571         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5572
5573         /* set MUX0/1/4/8 = 0 (AOW0) */
5574         {0x34, AC_VERB_SET_CONNECT_SEL, 0},
5575         {0x35, AC_VERB_SET_CONNECT_SEL, 0},
5576         {0x37, AC_VERB_SET_CONNECT_SEL, 0},
5577         {0x3b, AC_VERB_SET_CONNECT_SEL, 0},
5578
5579         /* set PW0 index=0 (MW0) */
5580         {0x24, AC_VERB_SET_CONNECT_SEL, 0},
5581
5582         /* Enable AOW0 to MW9 */
5583         {0x1, 0xfb8, 0x88},
5584         { }
5585 };
5586
5587
5588 static struct hda_verb vt2002P_uniwill_init_verbs[] = {
5589         {0x25, AC_VERB_SET_UNSOLICITED_ENABLE,
5590          AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
5591         {0x26, AC_VERB_SET_UNSOLICITED_ENABLE,
5592          AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
5593         {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5594         {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5595         {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5596         { }
5597 };
5598
5599 static struct hda_pcm_stream vt2002P_pcm_analog_playback = {
5600         .substreams = 2,
5601         .channels_min = 2,
5602         .channels_max = 2,
5603         .nid = 0x8, /* NID to query formats and rates */
5604         .ops = {
5605                 .open = via_playback_pcm_open,
5606                 .prepare = via_playback_multi_pcm_prepare,
5607                 .cleanup = via_playback_multi_pcm_cleanup,
5608                 .close = via_pcm_open_close,
5609         },
5610 };
5611
5612 static struct hda_pcm_stream vt2002P_pcm_analog_capture = {
5613         .substreams = 2,
5614         .channels_min = 2,
5615         .channels_max = 2,
5616         .nid = 0x10, /* NID to query formats and rates */
5617         .ops = {
5618                 .open = via_pcm_open_close,
5619                 .prepare = via_capture_pcm_prepare,
5620                 .cleanup = via_capture_pcm_cleanup,
5621                 .close = via_pcm_open_close,
5622         },
5623 };
5624
5625 static struct hda_pcm_stream vt2002P_pcm_digital_playback = {
5626         .substreams = 1,
5627         .channels_min = 2,
5628         .channels_max = 2,
5629         /* NID is set in via_build_pcms */
5630         .ops = {
5631                 .open = via_dig_playback_pcm_open,
5632                 .close = via_dig_playback_pcm_close,
5633                 .prepare = via_dig_playback_pcm_prepare,
5634                 .cleanup = via_dig_playback_pcm_cleanup
5635         },
5636 };
5637
5638 /* fill in the dac_nids table from the parsed pin configuration */
5639 static int vt2002P_auto_fill_dac_nids(struct via_spec *spec,
5640                                       const struct auto_pin_cfg *cfg)
5641 {
5642         spec->multiout.num_dacs = 1;
5643         spec->multiout.dac_nids = spec->private_dac_nids;
5644         if (cfg->line_out_pins[0])
5645                 spec->multiout.dac_nids[0] = 0x8;
5646         return 0;
5647 }
5648
5649 /* add playback controls from the parsed DAC table */
5650 static int vt2002P_auto_create_multi_out_ctls(struct via_spec *spec,
5651                                              const struct auto_pin_cfg *cfg)
5652 {
5653         int err;
5654
5655         if (!cfg->line_out_pins[0])
5656                 return -1;
5657
5658
5659         /* Line-Out: PortE */
5660         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
5661                               "Master Front Playback Volume",
5662                               HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT));
5663         if (err < 0)
5664                 return err;
5665         err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE,
5666                               "Master Front Playback Switch",
5667                               HDA_COMPOSE_AMP_VAL(0x26, 3, 0, HDA_OUTPUT));
5668         if (err < 0)
5669                 return err;
5670
5671         return 0;
5672 }
5673
5674 static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
5675 {
5676         int err;
5677
5678         if (!pin)
5679                 return 0;
5680
5681         spec->multiout.hp_nid = 0x9;
5682         spec->hp_independent_mode_index = 1;
5683
5684         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
5685                               "Headphone Playback Volume",
5686                               HDA_COMPOSE_AMP_VAL(
5687                                       spec->multiout.hp_nid, 3, 0, HDA_OUTPUT));
5688         if (err < 0)
5689                 return err;
5690
5691         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
5692                               "Headphone Playback Switch",
5693                               HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
5694         if (err < 0)
5695                 return err;
5696
5697         create_hp_imux(spec);
5698         return 0;
5699 }
5700
5701 /* create playback/capture controls for input pins */
5702 static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec,
5703                                                 const struct auto_pin_cfg *cfg)
5704 {
5705         static char *labels[] = {
5706                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
5707         };
5708         struct hda_input_mux *imux = &spec->private_imux[0];
5709         int i, err, idx = 0;
5710
5711         for (i = 0; i < AUTO_PIN_LAST; i++) {
5712                 if (!cfg->input_pins[i])
5713                         continue;
5714
5715                 switch (cfg->input_pins[i]) {
5716                 case 0x2b: /* Mic */
5717                         idx = 0;
5718                         break;
5719
5720                 case 0x2a: /* Line In */
5721                         idx = 1;
5722                         break;
5723
5724                 case 0x29: /* Front Mic */
5725                         idx = 2;
5726                         break;
5727                 }
5728                 err = via_new_analog_input(spec, labels[i], idx, 0x21);
5729                 if (err < 0)
5730                         return err;
5731                 imux->items[imux->num_items].label = labels[i];
5732                 imux->items[imux->num_items].index = idx;
5733                 imux->num_items++;
5734         }
5735
5736         /* build volume/mute control of loopback */
5737         err = via_new_analog_input(spec, "Stereo Mixer", 3, 0x21);
5738         if (err < 0)
5739                 return err;
5740
5741         /* for internal loopback recording select */
5742         imux->items[imux->num_items].label = "Stereo Mixer";
5743         imux->items[imux->num_items].index = 3;
5744         imux->num_items++;
5745
5746         /* for digital mic select */
5747         imux->items[imux->num_items].label = "Digital Mic";
5748         imux->items[imux->num_items].index = 4;
5749         imux->num_items++;
5750
5751         return 0;
5752 }
5753
5754 static int vt2002P_parse_auto_config(struct hda_codec *codec)
5755 {
5756         struct via_spec *spec = codec->spec;
5757         int err;
5758
5759
5760         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
5761         if (err < 0)
5762                 return err;
5763
5764         err = vt2002P_auto_fill_dac_nids(spec, &spec->autocfg);
5765         if (err < 0)
5766                 return err;
5767
5768         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
5769                 return 0; /* can't find valid BIOS pin config */
5770
5771         err = vt2002P_auto_create_multi_out_ctls(spec, &spec->autocfg);
5772         if (err < 0)
5773                 return err;
5774         err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
5775         if (err < 0)
5776                 return err;
5777         err = vt2002P_auto_create_analog_input_ctls(spec, &spec->autocfg);
5778         if (err < 0)
5779                 return err;
5780
5781         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5782
5783         fill_dig_outs(codec);
5784
5785         if (spec->kctls.list)
5786                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
5787
5788         spec->input_mux = &spec->private_imux[0];
5789
5790         if (spec->hp_mux)
5791                 via_hp_build(codec);
5792
5793         return 1;
5794 }
5795
5796 #ifdef CONFIG_SND_HDA_POWER_SAVE
5797 static struct hda_amp_list vt2002P_loopbacks[] = {
5798         { 0x21, HDA_INPUT, 0 },
5799         { 0x21, HDA_INPUT, 1 },
5800         { 0x21, HDA_INPUT, 2 },
5801         { } /* end */
5802 };
5803 #endif
5804
5805
5806 /* patch for vt2002P */
5807 static int patch_vt2002P(struct hda_codec *codec)
5808 {
5809         struct via_spec *spec;
5810         int err;
5811
5812         /* create a codec specific record */
5813         spec = via_new_spec(codec);
5814         if (spec == NULL)
5815                 return -ENOMEM;
5816
5817         /* automatic parse from the BIOS config */
5818         err = vt2002P_parse_auto_config(codec);
5819         if (err < 0) {
5820                 via_free(codec);
5821                 return err;
5822         } else if (!err) {
5823                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
5824                        "from BIOS.  Using genenic mode...\n");
5825         }
5826
5827         spec->init_verbs[spec->num_iverbs++]  = vt2002P_volume_init_verbs;
5828         spec->init_verbs[spec->num_iverbs++] = vt2002P_uniwill_init_verbs;
5829
5830         spec->stream_name_analog = "VT2002P Analog";
5831         spec->stream_analog_playback = &vt2002P_pcm_analog_playback;
5832         spec->stream_analog_capture = &vt2002P_pcm_analog_capture;
5833
5834         spec->stream_name_digital = "VT2002P Digital";
5835         spec->stream_digital_playback = &vt2002P_pcm_digital_playback;
5836
5837         if (!spec->adc_nids && spec->input_mux) {
5838                 spec->adc_nids = vt2002P_adc_nids;
5839                 spec->num_adc_nids = ARRAY_SIZE(vt2002P_adc_nids);
5840                 get_mux_nids(codec);
5841                 override_mic_boost(codec, 0x2b, 0, 3, 40);
5842                 override_mic_boost(codec, 0x29, 0, 3, 40);
5843                 spec->mixers[spec->num_mixers] = vt2002P_capture_mixer;
5844                 spec->num_mixers++;
5845         }
5846
5847         codec->patch_ops = via_patch_ops;
5848
5849         codec->patch_ops.init = via_auto_init;
5850         codec->patch_ops.unsol_event = via_unsol_event;
5851
5852 #ifdef CONFIG_SND_HDA_POWER_SAVE
5853         spec->loopback.amplist = vt2002P_loopbacks;
5854 #endif
5855
5856         return 0;
5857 }
5858
5859 /* for vt1812 */
5860
5861 /* capture mixer elements */
5862 static struct snd_kcontrol_new vt1812_capture_mixer[] = {
5863         HDA_CODEC_VOLUME("Capture Volume", 0x10, 0x0, HDA_INPUT),
5864         HDA_CODEC_MUTE("Capture Switch", 0x10, 0x0, HDA_INPUT),
5865         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x11, 0x0, HDA_INPUT),
5866         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x11, 0x0, HDA_INPUT),
5867         HDA_CODEC_MUTE("Mic Boost Capture Volume", 0x2b, 0x0, HDA_INPUT),
5868         HDA_CODEC_MUTE("Front Mic Boost Capture Volume", 0x29, 0x0,
5869                        HDA_INPUT),
5870         {
5871                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5872                 /* The multiple "Capture Source" controls confuse alsamixer
5873                  * So call somewhat different..
5874                  */
5875                 .name = "Input Source",
5876                 .count = 2,
5877                 .info = via_mux_enum_info,
5878                 .get = via_mux_enum_get,
5879                 .put = via_mux_enum_put,
5880         },
5881         { } /* end */
5882 };
5883
5884 static struct hda_verb vt1812_volume_init_verbs[] = {
5885         /*
5886          * Unmute ADC0-1 and set the default input to mic-in
5887          */
5888         {0x8, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5889         {0x9, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5890
5891
5892         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5893          * mixer widget
5894          */
5895         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
5896         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5897         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5898         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5899         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5900         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5901
5902         /* MUX Indices: Mic = 0 */
5903         {0x1e, AC_VERB_SET_CONNECT_SEL, 0},
5904         {0x1f, AC_VERB_SET_CONNECT_SEL, 0},
5905
5906         /* PW9 Output enable */
5907         {0x2d, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_OUT_EN},
5908
5909         /* Enable Boost Volume backdoor */
5910         {0x1, 0xfb9, 0x24},
5911
5912         /* MW0/1/4/13/15: un-mute index 0 (MUXx), un-mute index 1 (MW9) */
5913         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5914         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5915         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5916         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5917         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5918         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5919         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5920         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5921         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5922         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5923
5924         /* set MUX0/1/4/13/15 = 0 (AOW0) */
5925         {0x34, AC_VERB_SET_CONNECT_SEL, 0},
5926         {0x35, AC_VERB_SET_CONNECT_SEL, 0},
5927         {0x38, AC_VERB_SET_CONNECT_SEL, 0},
5928         {0x3c, AC_VERB_SET_CONNECT_SEL, 0},
5929         {0x3d, AC_VERB_SET_CONNECT_SEL, 0},
5930
5931         /* Enable AOW0 to MW9 */
5932         {0x1, 0xfb8, 0xa8},
5933         { }
5934 };
5935
5936
5937 static struct hda_verb vt1812_uniwill_init_verbs[] = {
5938         {0x33, AC_VERB_SET_UNSOLICITED_ENABLE,
5939          AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
5940         {0x25, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT },
5941         {0x28, AC_VERB_SET_UNSOLICITED_ENABLE,
5942          AC_USRSP_EN | VIA_JACK_EVENT | VIA_BIND_HP_EVENT},
5943         {0x29, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5944         {0x2a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5945         {0x2b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_JACK_EVENT},
5946         { }
5947 };
5948
5949 static struct hda_pcm_stream vt1812_pcm_analog_playback = {
5950         .substreams = 2,
5951         .channels_min = 2,
5952         .channels_max = 2,
5953         .nid = 0x8, /* NID to query formats and rates */
5954         .ops = {
5955                 .open = via_playback_pcm_open,
5956                 .prepare = via_playback_multi_pcm_prepare,
5957                 .cleanup = via_playback_multi_pcm_cleanup,
5958                 .close = via_pcm_open_close,
5959         },
5960 };
5961
5962 static struct hda_pcm_stream vt1812_pcm_analog_capture = {
5963         .substreams = 2,
5964         .channels_min = 2,
5965         .channels_max = 2,
5966         .nid = 0x10, /* NID to query formats and rates */
5967         .ops = {
5968                 .open = via_pcm_open_close,
5969                 .prepare = via_capture_pcm_prepare,
5970                 .cleanup = via_capture_pcm_cleanup,
5971                 .close = via_pcm_open_close,
5972         },
5973 };
5974
5975 static struct hda_pcm_stream vt1812_pcm_digital_playback = {
5976         .substreams = 1,
5977         .channels_min = 2,
5978         .channels_max = 2,
5979         /* NID is set in via_build_pcms */
5980         .ops = {
5981                 .open = via_dig_playback_pcm_open,
5982                 .close = via_dig_playback_pcm_close,
5983                 .prepare = via_dig_playback_pcm_prepare,
5984                 .cleanup = via_dig_playback_pcm_cleanup
5985         },
5986 };
5987 /* fill in the dac_nids table from the parsed pin configuration */
5988 static int vt1812_auto_fill_dac_nids(struct via_spec *spec,
5989                                      const struct auto_pin_cfg *cfg)
5990 {
5991         spec->multiout.num_dacs = 1;
5992         spec->multiout.dac_nids = spec->private_dac_nids;
5993         if (cfg->line_out_pins[0])
5994                 spec->multiout.dac_nids[0] = 0x8;
5995         return 0;
5996 }
5997
5998
5999 /* add playback controls from the parsed DAC table */
6000 static int vt1812_auto_create_multi_out_ctls(struct via_spec *spec,
6001                                              const struct auto_pin_cfg *cfg)
6002 {
6003         int err;
6004
6005         if (!cfg->line_out_pins[0])
6006                 return -1;
6007
6008         /* Line-Out: PortE */
6009         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
6010                               "Front Playback Volume",
6011                               HDA_COMPOSE_AMP_VAL(0x8, 3, 0, HDA_OUTPUT));
6012         if (err < 0)
6013                 return err;
6014         err = via_add_control(spec, VIA_CTL_WIDGET_BIND_PIN_MUTE,
6015                               "Front Playback Switch",
6016                               HDA_COMPOSE_AMP_VAL(0x28, 3, 0, HDA_OUTPUT));
6017         if (err < 0)
6018                 return err;
6019
6020         return 0;
6021 }
6022
6023 static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
6024 {
6025         int err;
6026
6027         if (!pin)
6028                 return 0;
6029
6030         spec->multiout.hp_nid = 0x9;
6031         spec->hp_independent_mode_index = 1;
6032
6033
6034         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
6035                               "Headphone Playback Volume",
6036                               HDA_COMPOSE_AMP_VAL(
6037                                       spec->multiout.hp_nid, 3, 0, HDA_OUTPUT));
6038         if (err < 0)
6039                 return err;
6040
6041         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
6042                               "Headphone Playback Switch",
6043                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
6044         if (err < 0)
6045                 return err;
6046
6047         create_hp_imux(spec);
6048         return 0;
6049 }
6050
6051 /* create playback/capture controls for input pins */
6052 static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec,
6053                                                 const struct auto_pin_cfg *cfg)
6054 {
6055         static char *labels[] = {
6056                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
6057         };
6058         struct hda_input_mux *imux = &spec->private_imux[0];
6059         int i, err, idx = 0;
6060
6061         for (i = 0; i < AUTO_PIN_LAST; i++) {
6062                 if (!cfg->input_pins[i])
6063                         continue;
6064
6065                 switch (cfg->input_pins[i]) {
6066                 case 0x2b: /* Mic */
6067                         idx = 0;
6068                         break;
6069
6070                 case 0x2a: /* Line In */
6071                         idx = 1;
6072                         break;
6073
6074                 case 0x29: /* Front Mic */
6075                         idx = 2;
6076                         break;
6077                 }
6078                 err = via_new_analog_input(spec, labels[i], idx, 0x21);
6079                 if (err < 0)
6080                         return err;
6081                 imux->items[imux->num_items].label = labels[i];
6082                 imux->items[imux->num_items].index = idx;
6083                 imux->num_items++;
6084         }
6085         /* build volume/mute control of loopback */
6086         err = via_new_analog_input(spec, "Stereo Mixer", 5, 0x21);
6087         if (err < 0)
6088                 return err;
6089
6090         /* for internal loopback recording select */
6091         imux->items[imux->num_items].label = "Stereo Mixer";
6092         imux->items[imux->num_items].index = 5;
6093         imux->num_items++;
6094
6095         /* for digital mic select */
6096         imux->items[imux->num_items].label = "Digital Mic";
6097         imux->items[imux->num_items].index = 6;
6098         imux->num_items++;
6099
6100         return 0;
6101 }
6102
6103 static int vt1812_parse_auto_config(struct hda_codec *codec)
6104 {
6105         struct via_spec *spec = codec->spec;
6106         int err;
6107
6108
6109         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
6110         if (err < 0)
6111                 return err;
6112         fill_dig_outs(codec);
6113         err = vt1812_auto_fill_dac_nids(spec, &spec->autocfg);
6114         if (err < 0)
6115                 return err;
6116
6117         if (!spec->autocfg.line_outs && !spec->autocfg.hp_outs)
6118                 return 0; /* can't find valid BIOS pin config */
6119
6120         err = vt1812_auto_create_multi_out_ctls(spec, &spec->autocfg);
6121         if (err < 0)
6122                 return err;
6123         err = vt1812_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
6124         if (err < 0)
6125                 return err;
6126         err = vt1812_auto_create_analog_input_ctls(spec, &spec->autocfg);
6127         if (err < 0)
6128                 return err;
6129
6130         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
6131
6132         fill_dig_outs(codec);
6133
6134         if (spec->kctls.list)
6135                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
6136
6137         spec->input_mux = &spec->private_imux[0];
6138
6139         if (spec->hp_mux)
6140                 via_hp_build(codec);
6141
6142         return 1;
6143 }
6144
6145 #ifdef CONFIG_SND_HDA_POWER_SAVE
6146 static struct hda_amp_list vt1812_loopbacks[] = {
6147         { 0x21, HDA_INPUT, 0 },
6148         { 0x21, HDA_INPUT, 1 },
6149         { 0x21, HDA_INPUT, 2 },
6150         { } /* end */
6151 };
6152 #endif
6153
6154
6155 /* patch for vt1812 */
6156 static int patch_vt1812(struct hda_codec *codec)
6157 {
6158         struct via_spec *spec;
6159         int err;
6160
6161         /* create a codec specific record */
6162         spec = via_new_spec(codec);
6163         if (spec == NULL)
6164                 return -ENOMEM;
6165
6166         /* automatic parse from the BIOS config */
6167         err = vt1812_parse_auto_config(codec);
6168         if (err < 0) {
6169                 via_free(codec);
6170                 return err;
6171         } else if (!err) {
6172                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
6173                        "from BIOS.  Using genenic mode...\n");
6174         }
6175
6176
6177         spec->init_verbs[spec->num_iverbs++]  = vt1812_volume_init_verbs;
6178         spec->init_verbs[spec->num_iverbs++] = vt1812_uniwill_init_verbs;
6179
6180         spec->stream_name_analog = "VT1812 Analog";
6181         spec->stream_analog_playback = &vt1812_pcm_analog_playback;
6182         spec->stream_analog_capture = &vt1812_pcm_analog_capture;
6183
6184         spec->stream_name_digital = "VT1812 Digital";
6185         spec->stream_digital_playback = &vt1812_pcm_digital_playback;
6186
6187
6188         if (!spec->adc_nids && spec->input_mux) {
6189                 spec->adc_nids = vt1812_adc_nids;
6190                 spec->num_adc_nids = ARRAY_SIZE(vt1812_adc_nids);
6191                 get_mux_nids(codec);
6192                 override_mic_boost(codec, 0x2b, 0, 3, 40);
6193                 override_mic_boost(codec, 0x29, 0, 3, 40);
6194                 spec->mixers[spec->num_mixers] = vt1812_capture_mixer;
6195                 spec->num_mixers++;
6196         }
6197
6198         codec->patch_ops = via_patch_ops;
6199
6200         codec->patch_ops.init = via_auto_init;
6201         codec->patch_ops.unsol_event = via_unsol_event;
6202
6203 #ifdef CONFIG_SND_HDA_POWER_SAVE
6204         spec->loopback.amplist = vt1812_loopbacks;
6205 #endif
6206
6207         return 0;
6208 }
6209
6210 /*
6211  * patch entries
6212  */
6213 static struct hda_codec_preset snd_hda_preset_via[] = {
6214         { .id = 0x11061708, .name = "VT1708", .patch = patch_vt1708},
6215         { .id = 0x11061709, .name = "VT1708", .patch = patch_vt1708},
6216         { .id = 0x1106170a, .name = "VT1708", .patch = patch_vt1708},
6217         { .id = 0x1106170b, .name = "VT1708", .patch = patch_vt1708},
6218         { .id = 0x1106e710, .name = "VT1709 10-Ch",
6219           .patch = patch_vt1709_10ch},
6220         { .id = 0x1106e711, .name = "VT1709 10-Ch",
6221           .patch = patch_vt1709_10ch},
6222         { .id = 0x1106e712, .name = "VT1709 10-Ch",
6223           .patch = patch_vt1709_10ch},
6224         { .id = 0x1106e713, .name = "VT1709 10-Ch",
6225           .patch = patch_vt1709_10ch},
6226         { .id = 0x1106e714, .name = "VT1709 6-Ch",
6227           .patch = patch_vt1709_6ch},
6228         { .id = 0x1106e715, .name = "VT1709 6-Ch",
6229           .patch = patch_vt1709_6ch},
6230         { .id = 0x1106e716, .name = "VT1709 6-Ch",
6231           .patch = patch_vt1709_6ch},
6232         { .id = 0x1106e717, .name = "VT1709 6-Ch",
6233           .patch = patch_vt1709_6ch},
6234         { .id = 0x1106e720, .name = "VT1708B 8-Ch",
6235           .patch = patch_vt1708B_8ch},
6236         { .id = 0x1106e721, .name = "VT1708B 8-Ch",
6237           .patch = patch_vt1708B_8ch},
6238         { .id = 0x1106e722, .name = "VT1708B 8-Ch",
6239           .patch = patch_vt1708B_8ch},
6240         { .id = 0x1106e723, .name = "VT1708B 8-Ch",
6241           .patch = patch_vt1708B_8ch},
6242         { .id = 0x1106e724, .name = "VT1708B 4-Ch",
6243           .patch = patch_vt1708B_4ch},
6244         { .id = 0x1106e725, .name = "VT1708B 4-Ch",
6245           .patch = patch_vt1708B_4ch},
6246         { .id = 0x1106e726, .name = "VT1708B 4-Ch",
6247           .patch = patch_vt1708B_4ch},
6248         { .id = 0x1106e727, .name = "VT1708B 4-Ch",
6249           .patch = patch_vt1708B_4ch},
6250         { .id = 0x11060397, .name = "VT1708S",
6251           .patch = patch_vt1708S},
6252         { .id = 0x11061397, .name = "VT1708S",
6253           .patch = patch_vt1708S},
6254         { .id = 0x11062397, .name = "VT1708S",
6255           .patch = patch_vt1708S},
6256         { .id = 0x11063397, .name = "VT1708S",
6257           .patch = patch_vt1708S},
6258         { .id = 0x11064397, .name = "VT1708S",
6259           .patch = patch_vt1708S},
6260         { .id = 0x11065397, .name = "VT1708S",
6261           .patch = patch_vt1708S},
6262         { .id = 0x11066397, .name = "VT1708S",
6263           .patch = patch_vt1708S},
6264         { .id = 0x11067397, .name = "VT1708S",
6265           .patch = patch_vt1708S},
6266         { .id = 0x11060398, .name = "VT1702",
6267           .patch = patch_vt1702},
6268         { .id = 0x11061398, .name = "VT1702",
6269           .patch = patch_vt1702},
6270         { .id = 0x11062398, .name = "VT1702",
6271           .patch = patch_vt1702},
6272         { .id = 0x11063398, .name = "VT1702",
6273           .patch = patch_vt1702},
6274         { .id = 0x11064398, .name = "VT1702",
6275           .patch = patch_vt1702},
6276         { .id = 0x11065398, .name = "VT1702",
6277           .patch = patch_vt1702},
6278         { .id = 0x11066398, .name = "VT1702",
6279           .patch = patch_vt1702},
6280         { .id = 0x11067398, .name = "VT1702",
6281           .patch = patch_vt1702},
6282         { .id = 0x11060428, .name = "VT1718S",
6283           .patch = patch_vt1718S},
6284         { .id = 0x11064428, .name = "VT1718S",
6285           .patch = patch_vt1718S},
6286         { .id = 0x11060441, .name = "VT2020",
6287           .patch = patch_vt1718S},
6288         { .id = 0x11064441, .name = "VT1828S",
6289           .patch = patch_vt1718S},
6290         { .id = 0x11060433, .name = "VT1716S",
6291           .patch = patch_vt1716S},
6292         { .id = 0x1106a721, .name = "VT1716S",
6293           .patch = patch_vt1716S},
6294         { .id = 0x11060438, .name = "VT2002P", .patch = patch_vt2002P},
6295         { .id = 0x11064438, .name = "VT2002P", .patch = patch_vt2002P},
6296         { .id = 0x11060448, .name = "VT1812", .patch = patch_vt1812},
6297         { .id = 0x11060440, .name = "VT1818S",
6298           .patch = patch_vt1708S},
6299         {} /* terminator */
6300 };
6301
6302 MODULE_ALIAS("snd-hda-codec-id:1106*");
6303
6304 static struct hda_codec_preset_list via_list = {
6305         .preset = snd_hda_preset_via,
6306         .owner = THIS_MODULE,
6307 };
6308
6309 MODULE_LICENSE("GPL");
6310 MODULE_DESCRIPTION("VIA HD-audio codec");
6311
6312 static int __init patch_via_init(void)
6313 {
6314         return snd_hda_add_codec_preset(&via_list);
6315 }
6316
6317 static void __exit patch_via_exit(void)
6318 {
6319         snd_hda_delete_codec_preset(&via_list);
6320 }
6321
6322 module_init(patch_via_init)
6323 module_exit(patch_via_exit)