git.oblomov.eu Git - 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 VT1702/VT1708/VT1709 codec
   5  *
   6  * Copyright (c) 2006-2008 Lydia Wang <lydiawang@viatech.com>
   7  *                         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 /*                                                                           */
  40 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  41
  42
  43 #include <linux/init.h>
  44 #include <linux/delay.h>
  45 #include <linux/slab.h>
  46 #include <sound/core.h>
  47 #include <sound/asoundef.h>
  48 #include "hda_codec.h"
  49 #include "hda_local.h"
  50 #include "hda_patch.h"
  51
  52 /* amp values */
  53 #define AMP_VAL_IDX_SHIFT       19
  54 #define AMP_VAL_IDX_MASK        (0x0f<<19)
  55
  56 #define NUM_CONTROL_ALLOC       32
  57 #define NUM_VERB_ALLOC          32
  58
  59 /* Pin Widget NID */
  60 #define VT1708_HP_NID           0x13
  61 #define VT1708_DIGOUT_NID       0x14
  62 #define VT1708_DIGIN_NID        0x16
  63 #define VT1708_DIGIN_PIN        0x26
  64 #define VT1708_HP_PIN_NID       0x20
  65 #define VT1708_CD_PIN_NID       0x24
  66
  67 #define VT1709_HP_DAC_NID       0x28
  68 #define VT1709_DIGOUT_NID       0x13
  69 #define VT1709_DIGIN_NID        0x17
  70 #define VT1709_DIGIN_PIN        0x25
  71
  72 #define VT1708B_HP_NID          0x25
  73 #define VT1708B_DIGOUT_NID      0x12
  74 #define VT1708B_DIGIN_NID       0x15
  75 #define VT1708B_DIGIN_PIN       0x21
  76
  77 #define VT1708S_HP_NID          0x25
  78 #define VT1708S_DIGOUT_NID      0x12
  79
  80 #define VT1702_HP_NID           0x17
  81 #define VT1702_DIGOUT_NID       0x11
  82
  83 #define IS_VT1708_VENDORID(x)           ((x) >= 0x11061708 && (x) <= 0x1106170b)
  84 #define IS_VT1709_10CH_VENDORID(x)      ((x) >= 0x1106e710 && (x) <= 0x1106e713)
  85 #define IS_VT1709_6CH_VENDORID(x)       ((x) >= 0x1106e714 && (x) <= 0x1106e717)
  86 #define IS_VT1708B_8CH_VENDORID(x)      ((x) >= 0x1106e720 && (x) <= 0x1106e723)
  87 #define IS_VT1708B_4CH_VENDORID(x)      ((x) >= 0x1106e724 && (x) <= 0x1106e727)
  88 #define IS_VT1708S_VENDORID(x)          ((x) >= 0x11060397 && (x) <= 0x11067397)
  89 #define IS_VT1702_VENDORID(x)           ((x) >= 0x11060398 && (x) <= 0x11067398)
  90
  91 enum VIA_HDA_CODEC {
  92         UNKNOWN = -1,
  93         VT1708,
  94         VT1709_10CH,
  95         VT1709_6CH,
  96         VT1708B_8CH,
  97         VT1708B_4CH,
  98         VT1708S,
  99         VT1702,
 100         CODEC_TYPES,
 101 };
 102
 103 static enum VIA_HDA_CODEC get_codec_type(u32 vendor_id)
 104 {
 105         u16 ven_id = vendor_id >> 16;
 106         u16 dev_id = vendor_id & 0xffff;
 107         enum VIA_HDA_CODEC codec_type;
 108
 109         /* get codec type */
 110         if (ven_id != 0x1106)
 111                 codec_type = UNKNOWN;
 112         else if (dev_id >= 0x1708 && dev_id <= 0x170b)
 113                 codec_type = VT1708;
 114         else if (dev_id >= 0xe710 && dev_id <= 0xe713)
 115                 codec_type = VT1709_10CH;
 116         else if (dev_id >= 0xe714 && dev_id <= 0xe717)
 117                 codec_type = VT1709_6CH;
 118         else if (dev_id >= 0xe720 && dev_id <= 0xe723)
 119                 codec_type = VT1708B_8CH;
 120         else if (dev_id >= 0xe724 && dev_id <= 0xe727)
 121                 codec_type = VT1708B_4CH;
 122         else if ((dev_id & 0xfff) == 0x397
 123                  && (dev_id >> 12) < 8)
 124                 codec_type = VT1708S;
 125         else if ((dev_id & 0xfff) == 0x398
 126                  && (dev_id >> 12) < 8)
 127                 codec_type = VT1702;
 128         else
 129                 codec_type = UNKNOWN;
 130         return codec_type;
 131 };
 132
 133 #define VIA_HP_EVENT            0x01
 134 #define VIA_GPIO_EVENT          0x02
 135
 136 enum {
 137         VIA_CTL_WIDGET_VOL,
 138         VIA_CTL_WIDGET_MUTE,
 139 };
 140
 141 enum {
 142         AUTO_SEQ_FRONT = 0,
 143         AUTO_SEQ_SURROUND,
 144         AUTO_SEQ_CENLFE,
 145         AUTO_SEQ_SIDE
 146 };
 147
 148 #define get_amp_nid(kc) ((kc)->private_value & 0xffff)
 149
 150 /* Some VT1708S based boards gets the micboost setting wrong, so we have
 151  * to apply some brute-force and re-write the TLV's by software. */
 152 static int mic_boost_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 153                          unsigned int size, unsigned int __user *_tlv)
 154 {
 155         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 156         hda_nid_t nid = get_amp_nid(kcontrol);
 157
 158         if (get_codec_type(codec->vendor_id) == VT1708S
 159             && (nid == 0x1a || nid == 0x1e)) {
 160                 if (size < 4 * sizeof(unsigned int))
 161                         return -ENOMEM;
 162                 if (put_user(1, _tlv))  /* SNDRV_CTL_TLVT_DB_SCALE */
 163                         return -EFAULT;
 164                 if (put_user(2 * sizeof(unsigned int), _tlv + 1))
 165                         return -EFAULT;
 166                 if (put_user(0, _tlv + 2)) /* offset = 0 */
 167                         return -EFAULT;
 168                 if (put_user(1000, _tlv + 3)) /* step size = 10 dB */
 169                         return -EFAULT;
 170         }
 171         return 0;
 172 }
 173
 174 static int mic_boost_volume_info(struct snd_kcontrol *kcontrol,
 175                                  struct snd_ctl_elem_info *uinfo)
 176 {
 177         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 178         hda_nid_t nid = get_amp_nid(kcontrol);
 179
 180         if (get_codec_type(codec->vendor_id) == VT1708S
 181             && (nid == 0x1a || nid == 0x1e)) {
 182                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 183                 uinfo->count = 2;
 184                 uinfo->value.integer.min = 0;
 185                 uinfo->value.integer.max = 3;
 186         }
 187         return 0;
 188 }
 189
 190 static struct snd_kcontrol_new vt1708_control_templates[] = {
 191         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
 192         HDA_CODEC_MUTE(NULL, 0, 0, 0),
 193 };
 194
 195
 196 struct via_spec {
 197         /* codec parameterization */
 198         struct snd_kcontrol_new *mixers[3];
 199         unsigned int num_mixers;
 200
 201         struct hda_verb *init_verbs[5];
 202         unsigned int num_iverbs;
 203
 204         char *stream_name_analog;
 205         struct hda_pcm_stream *stream_analog_playback;
 206         struct hda_pcm_stream *stream_analog_capture;
 207
 208         char *stream_name_digital;
 209         struct hda_pcm_stream *stream_digital_playback;
 210         struct hda_pcm_stream *stream_digital_capture;
 211
 212         /* playback */
 213         struct hda_multi_out multiout;
 214         hda_nid_t extra_dig_out_nid;
 215
 216         /* capture */
 217         unsigned int num_adc_nids;
 218         hda_nid_t *adc_nids;
 219         hda_nid_t dig_in_nid;
 220
 221         /* capture source */
 222         const struct hda_input_mux *input_mux;
 223         unsigned int cur_mux[3];
 224
 225         /* PCM information */
 226         struct hda_pcm pcm_rec[3];
 227
 228         /* dynamic controls, init_verbs and input_mux */
 229         struct auto_pin_cfg autocfg;
 230         unsigned int num_kctl_alloc, num_kctl_used;
 231         struct snd_kcontrol_new *kctl_alloc;
 232         struct hda_input_mux private_imux[2];
 233         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 234
 235         /* HP mode source */
 236         const struct hda_input_mux *hp_mux;
 237         unsigned int hp_independent_mode;
 238
 239 #ifdef CONFIG_SND_HDA_POWER_SAVE
 240         struct hda_loopback_check loopback;
 241 #endif
 242 };
 243
 244 static hda_nid_t vt1708_adc_nids[2] = {
 245         /* ADC1-2 */
 246         0x15, 0x27
 247 };
 248
 249 static hda_nid_t vt1709_adc_nids[3] = {
 250         /* ADC1-2 */
 251         0x14, 0x15, 0x16
 252 };
 253
 254 static hda_nid_t vt1708B_adc_nids[2] = {
 255         /* ADC1-2 */
 256         0x13, 0x14
 257 };
 258
 259 static hda_nid_t vt1708S_adc_nids[2] = {
 260         /* ADC1-2 */
 261         0x13, 0x14
 262 };
 263
 264 static hda_nid_t vt1702_adc_nids[3] = {
 265         /* ADC1-2 */
 266         0x12, 0x20, 0x1F
 267 };
 268
 269 /* add dynamic controls */
 270 static int via_add_control(struct via_spec *spec, int type, const char *name,
 271                            unsigned long val)
 272 {
 273         struct snd_kcontrol_new *knew;
 274
 275         if (spec->num_kctl_used >= spec->num_kctl_alloc) {
 276                 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
 277
 278                 /* array + terminator */
 279                 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
 280                 if (!knew)
 281                         return -ENOMEM;
 282                 if (spec->kctl_alloc) {
 283                         memcpy(knew, spec->kctl_alloc,
 284                                sizeof(*knew) * spec->num_kctl_alloc);
 285                         kfree(spec->kctl_alloc);
 286                 }
 287                 spec->kctl_alloc = knew;
 288                 spec->num_kctl_alloc = num;
 289         }
 290
 291         knew = &spec->kctl_alloc[spec->num_kctl_used];
 292         *knew = vt1708_control_templates[type];
 293         knew->name = kstrdup(name, GFP_KERNEL);
 294
 295         if (!knew->name)
 296                 return -ENOMEM;
 297         knew->private_value = val;
 298         spec->num_kctl_used++;
 299         return 0;
 300 }
 301
 302 /* create input playback/capture controls for the given pin */
 303 static int via_new_analog_input(struct via_spec *spec, hda_nid_t pin,
 304                                 const char *ctlname, int idx, int mix_nid)
 305 {
 306         char name[32];
 307         int err;
 308
 309         sprintf(name, "%s Playback Volume", ctlname);
 310         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
 311                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 312         if (err < 0)
 313                 return err;
 314         sprintf(name, "%s Playback Switch", ctlname);
 315         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
 316                               HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 317         if (err < 0)
 318                 return err;
 319         return 0;
 320 }
 321
 322 static void via_auto_set_output_and_unmute(struct hda_codec *codec,
 323                                            hda_nid_t nid, int pin_type,
 324                                            int dac_idx)
 325 {
 326         /* set as output */
 327         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 328                             pin_type);
 329         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 330                             AMP_OUT_UNMUTE);
 331 }
 332
 333
 334 static void via_auto_init_multi_out(struct hda_codec *codec)
 335 {
 336         struct via_spec *spec = codec->spec;
 337         int i;
 338
 339         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
 340                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
 341                 if (nid)
 342                         via_auto_set_output_and_unmute(codec, nid, PIN_OUT, i);
 343         }
 344 }
 345
 346 static void via_auto_init_hp_out(struct hda_codec *codec)
 347 {
 348         struct via_spec *spec = codec->spec;
 349         hda_nid_t pin;
 350
 351         pin = spec->autocfg.hp_pins[0];
 352         if (pin) /* connect to front */
 353                 via_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 354 }
 355
 356 static void via_auto_init_analog_input(struct hda_codec *codec)
 357 {
 358         struct via_spec *spec = codec->spec;
 359         int i;
 360
 361         for (i = 0; i < AUTO_PIN_LAST; i++) {
 362                 hda_nid_t nid = spec->autocfg.input_pins[i];
 363
 364                 snd_hda_codec_write(codec, nid, 0,
 365                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 366                                     (i <= AUTO_PIN_FRONT_MIC ?
 367                                      PIN_VREF50 : PIN_IN));
 368
 369         }
 370 }
 371 /*
 372  * input MUX handling
 373  */
 374 static int via_mux_enum_info(struct snd_kcontrol *kcontrol,
 375                              struct snd_ctl_elem_info *uinfo)
 376 {
 377         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 378         struct via_spec *spec = codec->spec;
 379         return snd_hda_input_mux_info(spec->input_mux, uinfo);
 380 }
 381
 382 static int via_mux_enum_get(struct snd_kcontrol *kcontrol,
 383                             struct snd_ctl_elem_value *ucontrol)
 384 {
 385         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 386         struct via_spec *spec = codec->spec;
 387         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 388
 389         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 390         return 0;
 391 }
 392
 393 static int via_mux_enum_put(struct snd_kcontrol *kcontrol,
 394                             struct snd_ctl_elem_value *ucontrol)
 395 {
 396         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 397         struct via_spec *spec = codec->spec;
 398         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 399         unsigned int vendor_id = codec->vendor_id;
 400
 401         /* AIW0  lydia 060801 add for correct sw0 input select */
 402         if (IS_VT1708_VENDORID(vendor_id) && (adc_idx == 0))
 403                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 404                                              0x18, &spec->cur_mux[adc_idx]);
 405         else if ((IS_VT1709_10CH_VENDORID(vendor_id) ||
 406                   IS_VT1709_6CH_VENDORID(vendor_id)) && (adc_idx == 0))
 407                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 408                                              0x19, &spec->cur_mux[adc_idx]);
 409         else if ((IS_VT1708B_8CH_VENDORID(vendor_id) ||
 410                   IS_VT1708B_4CH_VENDORID(vendor_id)) && (adc_idx == 0))
 411                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 412                                              0x17, &spec->cur_mux[adc_idx]);
 413         else if (IS_VT1702_VENDORID(vendor_id) && (adc_idx == 0))
 414                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 415                                              0x13, &spec->cur_mux[adc_idx]);
 416         else
 417                 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
 418                                              spec->adc_nids[adc_idx],
 419                                              &spec->cur_mux[adc_idx]);
 420 }
 421
 422 static int via_independent_hp_info(struct snd_kcontrol *kcontrol,
 423                                    struct snd_ctl_elem_info *uinfo)
 424 {
 425         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 426         struct via_spec *spec = codec->spec;
 427         return snd_hda_input_mux_info(spec->hp_mux, uinfo);
 428 }
 429
 430 static int via_independent_hp_get(struct snd_kcontrol *kcontrol,
 431                                   struct snd_ctl_elem_value *ucontrol)
 432 {
 433         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 434         struct via_spec *spec = codec->spec;
 435         hda_nid_t nid = spec->autocfg.hp_pins[0];
 436         unsigned int pinsel = snd_hda_codec_read(codec, nid, 0,
 437                                                  AC_VERB_GET_CONNECT_SEL,
 438                                                  0x00);
 439
 440         ucontrol->value.enumerated.item[0] = pinsel;
 441
 442         return 0;
 443 }
 444
 445 static int via_independent_hp_put(struct snd_kcontrol *kcontrol,
 446                                   struct snd_ctl_elem_value *ucontrol)
 447 {
 448         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 449         struct via_spec *spec = codec->spec;
 450         hda_nid_t nid = spec->autocfg.hp_pins[0];
 451         unsigned int pinsel = ucontrol->value.enumerated.item[0];
 452         unsigned int con_nid = snd_hda_codec_read(codec, nid, 0,
 453                                          AC_VERB_GET_CONNECT_LIST, 0) & 0xff;
 454
 455         if (con_nid == spec->multiout.hp_nid) {
 456                 if (pinsel == 0) {
 457                         if (!spec->hp_independent_mode) {
 458                                 if (spec->multiout.num_dacs > 1)
 459                                         spec->multiout.num_dacs -= 1;
 460                                 spec->hp_independent_mode = 1;
 461                         }
 462                 } else if (pinsel == 1) {
 463                        if (spec->hp_independent_mode) {
 464                                 if (spec->multiout.num_dacs > 1)
 465                                         spec->multiout.num_dacs += 1;
 466                                 spec->hp_independent_mode = 0;
 467                        }
 468                 }
 469         } else {
 470                 if (pinsel == 0) {
 471                         if (spec->hp_independent_mode) {
 472                                 if (spec->multiout.num_dacs > 1)
 473                                         spec->multiout.num_dacs += 1;
 474                                 spec->hp_independent_mode = 0;
 475                         }
 476                 } else if (pinsel == 1) {
 477                        if (!spec->hp_independent_mode) {
 478                                 if (spec->multiout.num_dacs > 1)
 479                                         spec->multiout.num_dacs -= 1;
 480                                 spec->hp_independent_mode = 1;
 481                        }
 482                 }
 483         }
 484         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL,
 485                             pinsel);
 486
 487         if (spec->multiout.hp_nid &&
 488             spec->multiout.hp_nid != spec->multiout.dac_nids[HDA_FRONT])
 489                         snd_hda_codec_setup_stream(codec,
 490                                                    spec->multiout.hp_nid,
 491                                                    0, 0, 0);
 492
 493         return 0;
 494 }
 495
 496 static struct snd_kcontrol_new via_hp_mixer[] = {
 497         {
 498                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 499                 .name = "Independent HP",
 500                 .count = 1,
 501                 .info = via_independent_hp_info,
 502                 .get = via_independent_hp_get,
 503                 .put = via_independent_hp_put,
 504         },
 505         { } /* end */
 506 };
 507
 508 /* capture mixer elements */
 509 static struct snd_kcontrol_new vt1708_capture_mixer[] = {
 510         HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_INPUT),
 511         HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_INPUT),
 512         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x27, 0x0, HDA_INPUT),
 513         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x27, 0x0, HDA_INPUT),
 514         {
 515                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 516                 /* The multiple "Capture Source" controls confuse alsamixer
 517                  * So call somewhat different..
 518                  */
 519                 /* .name = "Capture Source", */
 520                 .name = "Input Source",
 521                 .count = 1,
 522                 .info = via_mux_enum_info,
 523                 .get = via_mux_enum_get,
 524                 .put = via_mux_enum_put,
 525         },
 526         { } /* end */
 527 };
 528 /*
 529  * generic initialization of ADC, input mixers and output mixers
 530  */
 531 static struct hda_verb vt1708_volume_init_verbs[] = {
 532         /*
 533          * Unmute ADC0-1 and set the default input to mic-in
 534          */
 535         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 536         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 537
 538
 539         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 540          * mixer widget
 541          */
 542         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
 543         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 544         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 545         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
 546         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
 547         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
 548
 549         /*
 550          * Set up output mixers (0x19 - 0x1b)
 551          */
 552         /* set vol=0 to output mixers */
 553         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 554         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 555         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 556
 557         /* Setup default input to PW4 */
 558         {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
 559         /* PW9 Output enable */
 560         {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 561         { }
 562 };
 563
 564 static int via_playback_pcm_open(struct hda_pcm_stream *hinfo,
 565                                  struct hda_codec *codec,
 566                                  struct snd_pcm_substream *substream)
 567 {
 568         struct via_spec *spec = codec->spec;
 569         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 570                                              hinfo);
 571 }
 572
 573 static int via_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 574                                     struct hda_codec *codec,
 575                                     unsigned int stream_tag,
 576                                     unsigned int format,
 577                                     struct snd_pcm_substream *substream)
 578 {
 579         struct via_spec *spec = codec->spec;
 580         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
 581                                                 stream_tag, format, substream);
 582 }
 583
 584 static int via_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 585                                     struct hda_codec *codec,
 586                                     struct snd_pcm_substream *substream)
 587 {
 588         struct via_spec *spec = codec->spec;
 589         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 590 }
 591
 592
 593 static void playback_multi_pcm_prep_0(struct hda_codec *codec,
 594                                       unsigned int stream_tag,
 595                                       unsigned int format,
 596                                       struct snd_pcm_substream *substream)
 597 {
 598         struct via_spec *spec = codec->spec;
 599         struct hda_multi_out *mout = &spec->multiout;
 600         hda_nid_t *nids = mout->dac_nids;
 601         int chs = substream->runtime->channels;
 602         int i;
 603
 604         mutex_lock(&codec->spdif_mutex);
 605         if (mout->dig_out_nid && mout->dig_out_used != HDA_DIG_EXCLUSIVE) {
 606                 if (chs == 2 &&
 607                     snd_hda_is_supported_format(codec, mout->dig_out_nid,
 608                                                 format) &&
 609                     !(codec->spdif_status & IEC958_AES0_NONAUDIO)) {
 610                         mout->dig_out_used = HDA_DIG_ANALOG_DUP;
 611                         /* turn off SPDIF once; otherwise the IEC958 bits won't
 612                          * be updated */
 613                         if (codec->spdif_ctls & AC_DIG1_ENABLE)
 614                                 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
 615                                                     AC_VERB_SET_DIGI_CONVERT_1,
 616                                                     codec->spdif_ctls &
 617                                                         ~AC_DIG1_ENABLE & 0xff);
 618                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
 619                                                    stream_tag, 0, format);
 620                         /* turn on again (if needed) */
 621                         if (codec->spdif_ctls & AC_DIG1_ENABLE)
 622                                 snd_hda_codec_write(codec, mout->dig_out_nid, 0,
 623                                                     AC_VERB_SET_DIGI_CONVERT_1,
 624                                                     codec->spdif_ctls & 0xff);
 625                 } else {
 626                         mout->dig_out_used = 0;
 627                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
 628                                                    0, 0, 0);
 629                 }
 630         }
 631         mutex_unlock(&codec->spdif_mutex);
 632
 633         /* front */
 634         snd_hda_codec_setup_stream(codec, nids[HDA_FRONT], stream_tag,
 635                                    0, format);
 636
 637         if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
 638             !spec->hp_independent_mode)
 639                 /* headphone out will just decode front left/right (stereo) */
 640                 snd_hda_codec_setup_stream(codec, mout->hp_nid, stream_tag,
 641                                            0, format);
 642
 643         /* extra outputs copied from front */
 644         for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
 645                 if (mout->extra_out_nid[i])
 646                         snd_hda_codec_setup_stream(codec,
 647                                                    mout->extra_out_nid[i],
 648                                                    stream_tag, 0, format);
 649
 650         /* surrounds */
 651         for (i = 1; i < mout->num_dacs; i++) {
 652                 if (chs >= (i + 1) * 2) /* independent out */
 653                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
 654                                                    i * 2, format);
 655                 else /* copy front */
 656                         snd_hda_codec_setup_stream(codec, nids[i], stream_tag,
 657                                                    0, format);
 658         }
 659 }
 660
 661 static int via_playback_multi_pcm_prepare(struct hda_pcm_stream *hinfo,
 662                                           struct hda_codec *codec,
 663                                           unsigned int stream_tag,
 664                                           unsigned int format,
 665                                           struct snd_pcm_substream *substream)
 666 {
 667         struct via_spec *spec = codec->spec;
 668         struct hda_multi_out *mout = &spec->multiout;
 669         hda_nid_t *nids = mout->dac_nids;
 670
 671         if (substream->number == 0)
 672                 playback_multi_pcm_prep_0(codec, stream_tag, format,
 673                                           substream);
 674         else {
 675                 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
 676                     spec->hp_independent_mode)
 677                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
 678                                                    stream_tag, 0, format);
 679         }
 680
 681         return 0;
 682 }
 683
 684 static int via_playback_multi_pcm_cleanup(struct hda_pcm_stream *hinfo,
 685                                     struct hda_codec *codec,
 686                                     struct snd_pcm_substream *substream)
 687 {
 688         struct via_spec *spec = codec->spec;
 689         struct hda_multi_out *mout = &spec->multiout;
 690         hda_nid_t *nids = mout->dac_nids;
 691         int i;
 692
 693         if (substream->number == 0) {
 694                 for (i = 0; i < mout->num_dacs; i++)
 695                         snd_hda_codec_setup_stream(codec, nids[i], 0, 0, 0);
 696
 697                 if (mout->hp_nid && !spec->hp_independent_mode)
 698                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
 699                                                    0, 0, 0);
 700
 701                 for (i = 0; i < ARRAY_SIZE(mout->extra_out_nid); i++)
 702                         if (mout->extra_out_nid[i])
 703                                 snd_hda_codec_setup_stream(codec,
 704                                                         mout->extra_out_nid[i],
 705                                                         0, 0, 0);
 706                 mutex_lock(&codec->spdif_mutex);
 707                 if (mout->dig_out_nid &&
 708                     mout->dig_out_used == HDA_DIG_ANALOG_DUP) {
 709                         snd_hda_codec_setup_stream(codec, mout->dig_out_nid,
 710                                                    0, 0, 0);
 711                         mout->dig_out_used = 0;
 712                 }
 713                 mutex_unlock(&codec->spdif_mutex);
 714         } else {
 715                 if (mout->hp_nid && mout->hp_nid != nids[HDA_FRONT] &&
 716                     spec->hp_independent_mode)
 717                         snd_hda_codec_setup_stream(codec, mout->hp_nid,
 718                                                    0, 0, 0);
 719         }
 720
 721         return 0;
 722 }
 723
 724 /*
 725  * Digital out
 726  */
 727 static int via_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 728                                      struct hda_codec *codec,
 729                                      struct snd_pcm_substream *substream)
 730 {
 731         struct via_spec *spec = codec->spec;
 732         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 733 }
 734
 735 static int via_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 736                                       struct hda_codec *codec,
 737                                       struct snd_pcm_substream *substream)
 738 {
 739         struct via_spec *spec = codec->spec;
 740         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 741 }
 742
 743 /* setup SPDIF output stream */
 744 static void setup_dig_playback_stream(struct hda_codec *codec, hda_nid_t nid,
 745                                  unsigned int stream_tag, unsigned int format)
 746 {
 747         /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
 748         if (codec->spdif_ctls & AC_DIG1_ENABLE)
 749                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 750                                     codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff);
 751         snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
 752         /* turn on again (if needed) */
 753         if (codec->spdif_ctls & AC_DIG1_ENABLE)
 754                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 755                                     codec->spdif_ctls & 0xff);
 756 }
 757
 758 static int via_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 759                                         struct hda_codec *codec,
 760                                         unsigned int stream_tag,
 761                                         unsigned int format,
 762                                         struct snd_pcm_substream *substream)
 763 {
 764         struct via_spec *spec = codec->spec;
 765         hda_nid_t nid;
 766
 767         /* 1st or 2nd S/PDIF */
 768         if (substream->number == 0)
 769                 nid = spec->multiout.dig_out_nid;
 770         else if (substream->number == 1)
 771                 nid = spec->extra_dig_out_nid;
 772         else
 773                 return -1;
 774
 775         mutex_lock(&codec->spdif_mutex);
 776         setup_dig_playback_stream(codec, nid, stream_tag, format);
 777         mutex_unlock(&codec->spdif_mutex);
 778         return 0;
 779 }
 780
 781 /*
 782  * Analog capture
 783  */
 784 static int via_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 785                                    struct hda_codec *codec,
 786                                    unsigned int stream_tag,
 787                                    unsigned int format,
 788                                    struct snd_pcm_substream *substream)
 789 {
 790         struct via_spec *spec = codec->spec;
 791
 792         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number],
 793                                    stream_tag, 0, format);
 794         return 0;
 795 }
 796
 797 static int via_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 798                                    struct hda_codec *codec,
 799                                    struct snd_pcm_substream *substream)
 800 {
 801         struct via_spec *spec = codec->spec;
 802         snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]);
 803         return 0;
 804 }
 805
 806 static struct hda_pcm_stream vt1708_pcm_analog_playback = {
 807         .substreams = 2,
 808         .channels_min = 2,
 809         .channels_max = 8,
 810         .nid = 0x10, /* NID to query formats and rates */
 811         .ops = {
 812                 .open = via_playback_pcm_open,
 813                 .prepare = via_playback_multi_pcm_prepare,
 814                 .cleanup = via_playback_multi_pcm_cleanup
 815         },
 816 };
 817
 818 static struct hda_pcm_stream vt1708_pcm_analog_s16_playback = {
 819         .substreams = 1,
 820         .channels_min = 2,
 821         .channels_max = 8,
 822         .nid = 0x10, /* NID to query formats and rates */
 823         /* We got noisy outputs on the right channel on VT1708 when
 824          * 24bit samples are used.  Until any workaround is found,
 825          * disable the 24bit format, so far.
 826          */
 827         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 828         .ops = {
 829                 .open = via_playback_pcm_open,
 830                 .prepare = via_playback_pcm_prepare,
 831                 .cleanup = via_playback_pcm_cleanup
 832         },
 833 };
 834
 835 static struct hda_pcm_stream vt1708_pcm_analog_capture = {
 836         .substreams = 2,
 837         .channels_min = 2,
 838         .channels_max = 2,
 839         .nid = 0x15, /* NID to query formats and rates */
 840         .ops = {
 841                 .prepare = via_capture_pcm_prepare,
 842                 .cleanup = via_capture_pcm_cleanup
 843         },
 844 };
 845
 846 static struct hda_pcm_stream vt1708_pcm_digital_playback = {
 847         .substreams = 1,
 848         .channels_min = 2,
 849         .channels_max = 2,
 850         /* NID is set in via_build_pcms */
 851         .ops = {
 852                 .open = via_dig_playback_pcm_open,
 853                 .close = via_dig_playback_pcm_close,
 854                 .prepare = via_dig_playback_pcm_prepare
 855         },
 856 };
 857
 858 static struct hda_pcm_stream vt1708_pcm_digital_capture = {
 859         .substreams = 1,
 860         .channels_min = 2,
 861         .channels_max = 2,
 862 };
 863
 864 static int via_build_controls(struct hda_codec *codec)
 865 {
 866         struct via_spec *spec = codec->spec;
 867         int err;
 868         int i;
 869
 870         for (i = 0; i < spec->num_mixers; i++) {
 871                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 872                 if (err < 0)
 873                         return err;
 874         }
 875
 876         if (spec->multiout.dig_out_nid) {
 877                 err = snd_hda_create_spdif_out_ctls(codec,
 878                                                     spec->multiout.dig_out_nid);
 879                 if (err < 0)
 880                         return err;
 881                 err = snd_hda_create_spdif_share_sw(codec,
 882                                                     &spec->multiout);
 883                 if (err < 0)
 884                         return err;
 885                 spec->multiout.share_spdif = 1;
 886
 887                 if (spec->extra_dig_out_nid) {
 888                         err = snd_hda_create_spdif_out_ctls(codec,
 889                                                     spec->extra_dig_out_nid);
 890                         if (err < 0)
 891                                 return err;
 892                 }
 893         }
 894         if (spec->dig_in_nid) {
 895                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 896                 if (err < 0)
 897                         return err;
 898         }
 899         return 0;
 900 }
 901
 902 static int via_build_pcms(struct hda_codec *codec)
 903 {
 904         struct via_spec *spec = codec->spec;
 905         struct hda_pcm *info = spec->pcm_rec;
 906
 907         codec->num_pcms = 1;
 908         codec->pcm_info = info;
 909
 910         info->name = spec->stream_name_analog;
 911         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
 912         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
 913         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
 914         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 915
 916         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
 917                 spec->multiout.max_channels;
 918
 919         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
 920                 codec->num_pcms++;
 921                 info++;
 922                 info->name = spec->stream_name_digital;
 923                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
 924                 if (spec->multiout.dig_out_nid) {
 925                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 926                                 *(spec->stream_digital_playback);
 927                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
 928                                 spec->multiout.dig_out_nid;
 929                 }
 930                 if (spec->dig_in_nid) {
 931                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
 932                                 *(spec->stream_digital_capture);
 933                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
 934                                 spec->dig_in_nid;
 935                 }
 936         }
 937
 938         return 0;
 939 }
 940
 941 static void via_free(struct hda_codec *codec)
 942 {
 943         struct via_spec *spec = codec->spec;
 944         unsigned int i;
 945
 946         if (!spec)
 947                 return;
 948
 949         if (spec->kctl_alloc) {
 950                 for (i = 0; i < spec->num_kctl_used; i++)
 951                         kfree(spec->kctl_alloc[i].name);
 952                 kfree(spec->kctl_alloc);
 953         }
 954
 955         kfree(codec->spec);
 956 }
 957
 958 /* mute internal speaker if HP is plugged */
 959 static void via_hp_automute(struct hda_codec *codec)
 960 {
 961         unsigned int present;
 962         struct via_spec *spec = codec->spec;
 963
 964         present = snd_hda_codec_read(codec, spec->autocfg.hp_pins[0], 0,
 965                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 966         snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
 967                                  HDA_OUTPUT, 0, HDA_AMP_MUTE,
 968                                  present ? HDA_AMP_MUTE : 0);
 969 }
 970
 971 static void via_gpio_control(struct hda_codec *codec)
 972 {
 973         unsigned int gpio_data;
 974         unsigned int vol_counter;
 975         unsigned int vol;
 976         unsigned int master_vol;
 977
 978         struct via_spec *spec = codec->spec;
 979
 980         gpio_data = snd_hda_codec_read(codec, codec->afg, 0,
 981                                        AC_VERB_GET_GPIO_DATA, 0) & 0x03;
 982
 983         vol_counter = (snd_hda_codec_read(codec, codec->afg, 0,
 984                                           0xF84, 0) & 0x3F0000) >> 16;
 985
 986         vol = vol_counter & 0x1F;
 987         master_vol = snd_hda_codec_read(codec, 0x1A, 0,
 988                                         AC_VERB_GET_AMP_GAIN_MUTE,
 989                                         AC_AMP_GET_INPUT);
 990
 991         if (gpio_data == 0x02) {
 992                 /* unmute line out */
 993                 snd_hda_codec_amp_stereo(codec, spec->autocfg.line_out_pins[0],
 994                                          HDA_OUTPUT, 0, HDA_AMP_MUTE, 0);
 995
 996                 if (vol_counter & 0x20) {
 997                         /* decrease volume */
 998                         if (vol > master_vol)
 999                                 vol = master_vol;
1000                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT,
1001                                                  0, HDA_AMP_VOLMASK,
1002                                                  master_vol-vol);
1003                 } else {
1004                         /* increase volume */
1005                         snd_hda_codec_amp_stereo(codec, 0x1A, HDA_INPUT, 0,
1006                                          HDA_AMP_VOLMASK,
1007                                          ((master_vol+vol) > 0x2A) ? 0x2A :
1008                                           (master_vol+vol));
1009                 }
1010         } else if (!(gpio_data & 0x02)) {
1011                 /* mute line out */
1012                 snd_hda_codec_amp_stereo(codec,
1013                                          spec->autocfg.line_out_pins[0],
1014                                          HDA_OUTPUT, 0, HDA_AMP_MUTE,
1015                                          HDA_AMP_MUTE);
1016         }
1017 }
1018
1019 /* unsolicited event for jack sensing */
1020 static void via_unsol_event(struct hda_codec *codec,
1021                                   unsigned int res)
1022 {
1023         res >>= 26;
1024         if (res == VIA_HP_EVENT)
1025                 via_hp_automute(codec);
1026         else if (res == VIA_GPIO_EVENT)
1027                 via_gpio_control(codec);
1028 }
1029
1030 static hda_nid_t slave_dig_outs[] = {
1031         0,
1032 };
1033
1034 static int via_init(struct hda_codec *codec)
1035 {
1036         struct via_spec *spec = codec->spec;
1037         int i;
1038         for (i = 0; i < spec->num_iverbs; i++)
1039                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
1040
1041         /* Lydia Add for EAPD enable */
1042         if (!spec->dig_in_nid) { /* No Digital In connection */
1043                 if (IS_VT1708_VENDORID(codec->vendor_id)) {
1044                         snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
1045                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1046                                             PIN_OUT);
1047                         snd_hda_codec_write(codec, VT1708_DIGIN_PIN, 0,
1048                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1049                 } else if (IS_VT1709_10CH_VENDORID(codec->vendor_id) ||
1050                            IS_VT1709_6CH_VENDORID(codec->vendor_id)) {
1051                         snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
1052                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1053                                             PIN_OUT);
1054                         snd_hda_codec_write(codec, VT1709_DIGIN_PIN, 0,
1055                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1056                 } else if (IS_VT1708B_8CH_VENDORID(codec->vendor_id) ||
1057                            IS_VT1708B_4CH_VENDORID(codec->vendor_id)) {
1058                         snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
1059                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1060                                             PIN_OUT);
1061                         snd_hda_codec_write(codec, VT1708B_DIGIN_PIN, 0,
1062                                             AC_VERB_SET_EAPD_BTLENABLE, 0x02);
1063                 }
1064         } else /* enable SPDIF-input pin */
1065                 snd_hda_codec_write(codec, spec->autocfg.dig_in_pin, 0,
1066                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN);
1067
1068         /* no slave outs */
1069         codec->slave_dig_outs = slave_dig_outs;
1070
1071         return 0;
1072 }
1073
1074 #ifdef CONFIG_SND_HDA_POWER_SAVE
1075 static int via_check_power_status(struct hda_codec *codec, hda_nid_t nid)
1076 {
1077         struct via_spec *spec = codec->spec;
1078         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
1079 }
1080 #endif
1081
1082 /*
1083  */
1084 static struct hda_codec_ops via_patch_ops = {
1085         .build_controls = via_build_controls,
1086         .build_pcms = via_build_pcms,
1087         .init = via_init,
1088         .free = via_free,
1089 #ifdef CONFIG_SND_HDA_POWER_SAVE
1090         .check_power_status = via_check_power_status,
1091 #endif
1092 };
1093
1094 /* fill in the dac_nids table from the parsed pin configuration */
1095 static int vt1708_auto_fill_dac_nids(struct via_spec *spec,
1096                                      const struct auto_pin_cfg *cfg)
1097 {
1098         int i;
1099         hda_nid_t nid;
1100
1101         spec->multiout.num_dacs = cfg->line_outs;
1102
1103         spec->multiout.dac_nids = spec->private_dac_nids;
1104
1105         for(i = 0; i < 4; i++) {
1106                 nid = cfg->line_out_pins[i];
1107                 if (nid) {
1108                         /* config dac list */
1109                         switch (i) {
1110                         case AUTO_SEQ_FRONT:
1111                                 spec->multiout.dac_nids[i] = 0x10;
1112                                 break;
1113                         case AUTO_SEQ_CENLFE:
1114                                 spec->multiout.dac_nids[i] = 0x12;
1115                                 break;
1116                         case AUTO_SEQ_SURROUND:
1117                                 spec->multiout.dac_nids[i] = 0x11;
1118                                 break;
1119                         case AUTO_SEQ_SIDE:
1120                                 spec->multiout.dac_nids[i] = 0x13;
1121                                 break;
1122                         }
1123                 }
1124         }
1125
1126         return 0;
1127 }
1128
1129 /* add playback controls from the parsed DAC table */
1130 static int vt1708_auto_create_multi_out_ctls(struct via_spec *spec,
1131                                              const struct auto_pin_cfg *cfg)
1132 {
1133         char name[32];
1134         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1135         hda_nid_t nid, nid_vol = 0;
1136         int i, err;
1137
1138         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1139                 nid = cfg->line_out_pins[i];
1140
1141                 if (!nid)
1142                         continue;
1143
1144                 if (i != AUTO_SEQ_FRONT)
1145                         nid_vol = 0x18 + i;
1146
1147                 if (i == AUTO_SEQ_CENLFE) {
1148                         /* Center/LFE */
1149                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1150                                         "Center Playback Volume",
1151                                         HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1152                                                             HDA_OUTPUT));
1153                         if (err < 0)
1154                                 return err;
1155                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1156                                               "LFE Playback Volume",
1157                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1158                                                                   HDA_OUTPUT));
1159                         if (err < 0)
1160                                 return err;
1161                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1162                                               "Center Playback Switch",
1163                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
1164                                                                   HDA_OUTPUT));
1165                         if (err < 0)
1166                                 return err;
1167                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1168                                               "LFE Playback Switch",
1169                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
1170                                                                   HDA_OUTPUT));
1171                         if (err < 0)
1172                                 return err;
1173                 } else if (i == AUTO_SEQ_FRONT){
1174                         /* add control to mixer index 0 */
1175                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1176                                               "Master Front Playback Volume",
1177                                               HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1178                                                                   HDA_INPUT));
1179                         if (err < 0)
1180                                 return err;
1181                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1182                                               "Master Front Playback Switch",
1183                                               HDA_COMPOSE_AMP_VAL(0x17, 3, 0,
1184                                                                   HDA_INPUT));
1185                         if (err < 0)
1186                                 return err;
1187
1188                         /* add control to PW3 */
1189                         sprintf(name, "%s Playback Volume", chname[i]);
1190                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1191                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1192                                                                   HDA_OUTPUT));
1193                         if (err < 0)
1194                                 return err;
1195                         sprintf(name, "%s Playback Switch", chname[i]);
1196                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1197                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1198                                                                   HDA_OUTPUT));
1199                         if (err < 0)
1200                                 return err;
1201                 } else {
1202                         sprintf(name, "%s Playback Volume", chname[i]);
1203                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1204                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1205                                                                   HDA_OUTPUT));
1206                         if (err < 0)
1207                                 return err;
1208                         sprintf(name, "%s Playback Switch", chname[i]);
1209                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1210                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
1211                                                                   HDA_OUTPUT));
1212                         if (err < 0)
1213                                 return err;
1214                 }
1215         }
1216
1217         return 0;
1218 }
1219
1220 static void create_hp_imux(struct via_spec *spec)
1221 {
1222         int i;
1223         struct hda_input_mux *imux = &spec->private_imux[1];
1224         static const char *texts[] = { "OFF", "ON", NULL};
1225
1226         /* for hp mode select */
1227         i = 0;
1228         while (texts[i] != NULL) {
1229                 imux->items[imux->num_items].label =  texts[i];
1230                 imux->items[imux->num_items].index = i;
1231                 imux->num_items++;
1232                 i++;
1233         }
1234
1235         spec->hp_mux = &spec->private_imux[1];
1236 }
1237
1238 static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1239 {
1240         int err;
1241
1242         if (!pin)
1243                 return 0;
1244
1245         spec->multiout.hp_nid = VT1708_HP_NID; /* AOW3 */
1246
1247         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1248                               "Headphone Playback Volume",
1249                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1250         if (err < 0)
1251                 return err;
1252         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1253                               "Headphone Playback Switch",
1254                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1255         if (err < 0)
1256                 return err;
1257
1258         create_hp_imux(spec);
1259
1260         return 0;
1261 }
1262
1263 /* create playback/capture controls for input pins */
1264 static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec,
1265                                                 const struct auto_pin_cfg *cfg)
1266 {
1267         static char *labels[] = {
1268                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1269         };
1270         struct hda_input_mux *imux = &spec->private_imux[0];
1271         int i, err, idx = 0;
1272
1273         /* for internal loopback recording select */
1274         imux->items[imux->num_items].label = "Stereo Mixer";
1275         imux->items[imux->num_items].index = idx;
1276         imux->num_items++;
1277
1278         for (i = 0; i < AUTO_PIN_LAST; i++) {
1279                 if (!cfg->input_pins[i])
1280                         continue;
1281
1282                 switch (cfg->input_pins[i]) {
1283                 case 0x1d: /* Mic */
1284                         idx = 2;
1285                         break;
1286
1287                 case 0x1e: /* Line In */
1288                         idx = 3;
1289                         break;
1290
1291                 case 0x21: /* Front Mic */
1292                         idx = 4;
1293                         break;
1294
1295                 case 0x24: /* CD */
1296                         idx = 1;
1297                         break;
1298                 }
1299                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1300                                            idx, 0x17);
1301                 if (err < 0)
1302                         return err;
1303                 imux->items[imux->num_items].label = labels[i];
1304                 imux->items[imux->num_items].index = idx;
1305                 imux->num_items++;
1306         }
1307         return 0;
1308 }
1309
1310 #ifdef CONFIG_SND_HDA_POWER_SAVE
1311 static struct hda_amp_list vt1708_loopbacks[] = {
1312         { 0x17, HDA_INPUT, 1 },
1313         { 0x17, HDA_INPUT, 2 },
1314         { 0x17, HDA_INPUT, 3 },
1315         { 0x17, HDA_INPUT, 4 },
1316         { } /* end */
1317 };
1318 #endif
1319
1320 static void vt1708_set_pinconfig_connect(struct hda_codec *codec, hda_nid_t nid)
1321 {
1322         unsigned int def_conf;
1323         unsigned char seqassoc;
1324
1325         def_conf = snd_hda_codec_read(codec, nid, 0,
1326                                       AC_VERB_GET_CONFIG_DEFAULT, 0);
1327         seqassoc = (unsigned char) get_defcfg_association(def_conf);
1328         seqassoc = (seqassoc << 4) | get_defcfg_sequence(def_conf);
1329         if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) {
1330                 if (seqassoc == 0xff) {
1331                         def_conf = def_conf & (~(AC_JACK_PORT_BOTH << 30));
1332                         snd_hda_codec_write(codec, nid, 0,
1333                                             AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
1334                                             def_conf >> 24);
1335                 }
1336         }
1337
1338         return;
1339 }
1340
1341 static int vt1708_parse_auto_config(struct hda_codec *codec)
1342 {
1343         struct via_spec *spec = codec->spec;
1344         int err;
1345
1346         /* Add HP and CD pin config connect bit re-config action */
1347         vt1708_set_pinconfig_connect(codec, VT1708_HP_PIN_NID);
1348         vt1708_set_pinconfig_connect(codec, VT1708_CD_PIN_NID);
1349
1350         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1351         if (err < 0)
1352                 return err;
1353         err = vt1708_auto_fill_dac_nids(spec, &spec->autocfg);
1354         if (err < 0)
1355                 return err;
1356         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1357                 return 0; /* can't find valid BIOS pin config */
1358
1359         err = vt1708_auto_create_multi_out_ctls(spec, &spec->autocfg);
1360         if (err < 0)
1361                 return err;
1362         err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1363         if (err < 0)
1364                 return err;
1365         err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg);
1366         if (err < 0)
1367                 return err;
1368
1369         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1370
1371         if (spec->autocfg.dig_out_pin)
1372                 spec->multiout.dig_out_nid = VT1708_DIGOUT_NID;
1373         if (spec->autocfg.dig_in_pin)
1374                 spec->dig_in_nid = VT1708_DIGIN_NID;
1375
1376         if (spec->kctl_alloc)
1377                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1378
1379         spec->init_verbs[spec->num_iverbs++] = vt1708_volume_init_verbs;
1380
1381         spec->input_mux = &spec->private_imux[0];
1382
1383         if (spec->hp_mux)
1384                 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1385
1386         return 1;
1387 }
1388
1389 /* init callback for auto-configuration model -- overriding the default init */
1390 static int via_auto_init(struct hda_codec *codec)
1391 {
1392         via_init(codec);
1393         via_auto_init_multi_out(codec);
1394         via_auto_init_hp_out(codec);
1395         via_auto_init_analog_input(codec);
1396         return 0;
1397 }
1398
1399 static int patch_vt1708(struct hda_codec *codec)
1400 {
1401         struct via_spec *spec;
1402         int err;
1403
1404         /* create a codec specific record */
1405         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1406         if (spec == NULL)
1407                 return -ENOMEM;
1408
1409         codec->spec = spec;
1410
1411         /* automatic parse from the BIOS config */
1412         err = vt1708_parse_auto_config(codec);
1413         if (err < 0) {
1414                 via_free(codec);
1415                 return err;
1416         } else if (!err) {
1417                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
1418                        "from BIOS.  Using genenic mode...\n");
1419         }
1420
1421
1422         spec->stream_name_analog = "VT1708 Analog";
1423         spec->stream_analog_playback = &vt1708_pcm_analog_playback;
1424         /* disable 32bit format on VT1708 */
1425         if (codec->vendor_id == 0x11061708)
1426                 spec->stream_analog_playback = &vt1708_pcm_analog_s16_playback;
1427         spec->stream_analog_capture = &vt1708_pcm_analog_capture;
1428
1429         spec->stream_name_digital = "VT1708 Digital";
1430         spec->stream_digital_playback = &vt1708_pcm_digital_playback;
1431         spec->stream_digital_capture = &vt1708_pcm_digital_capture;
1432
1433
1434         if (!spec->adc_nids && spec->input_mux) {
1435                 spec->adc_nids = vt1708_adc_nids;
1436                 spec->num_adc_nids = ARRAY_SIZE(vt1708_adc_nids);
1437                 spec->mixers[spec->num_mixers] = vt1708_capture_mixer;
1438                 spec->num_mixers++;
1439         }
1440
1441         codec->patch_ops = via_patch_ops;
1442
1443         codec->patch_ops.init = via_auto_init;
1444 #ifdef CONFIG_SND_HDA_POWER_SAVE
1445         spec->loopback.amplist = vt1708_loopbacks;
1446 #endif
1447
1448         return 0;
1449 }
1450
1451 /* capture mixer elements */
1452 static struct snd_kcontrol_new vt1709_capture_mixer[] = {
1453         HDA_CODEC_VOLUME("Capture Volume", 0x14, 0x0, HDA_INPUT),
1454         HDA_CODEC_MUTE("Capture Switch", 0x14, 0x0, HDA_INPUT),
1455         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x15, 0x0, HDA_INPUT),
1456         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x15, 0x0, HDA_INPUT),
1457         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x16, 0x0, HDA_INPUT),
1458         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x16, 0x0, HDA_INPUT),
1459         {
1460                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1461                 /* The multiple "Capture Source" controls confuse alsamixer
1462                  * So call somewhat different..
1463                  */
1464                 /* .name = "Capture Source", */
1465                 .name = "Input Source",
1466                 .count = 1,
1467                 .info = via_mux_enum_info,
1468                 .get = via_mux_enum_get,
1469                 .put = via_mux_enum_put,
1470         },
1471         { } /* end */
1472 };
1473
1474 static struct hda_verb vt1709_uniwill_init_verbs[] = {
1475         {0x20, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
1476         { }
1477 };
1478
1479 /*
1480  * generic initialization of ADC, input mixers and output mixers
1481  */
1482 static struct hda_verb vt1709_10ch_volume_init_verbs[] = {
1483         /*
1484          * Unmute ADC0-2 and set the default input to mic-in
1485          */
1486         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1487         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1488         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1489
1490
1491         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1492          * mixer widget
1493          */
1494         /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1495         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1496         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1497         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1498         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1499         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1500
1501         /*
1502          * Set up output selector (0x1a, 0x1b, 0x29)
1503          */
1504         /* set vol=0 to output mixers */
1505         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1506         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1507         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1508
1509         /*
1510          *  Unmute PW3 and PW4
1511          */
1512         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1513         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1514
1515         /* Set input of PW4 as AOW4 */
1516         {0x20, AC_VERB_SET_CONNECT_SEL, 0x1},
1517         /* PW9 Output enable */
1518         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1519         { }
1520 };
1521
1522 static struct hda_pcm_stream vt1709_10ch_pcm_analog_playback = {
1523         .substreams = 1,
1524         .channels_min = 2,
1525         .channels_max = 10,
1526         .nid = 0x10, /* NID to query formats and rates */
1527         .ops = {
1528                 .open = via_playback_pcm_open,
1529                 .prepare = via_playback_pcm_prepare,
1530                 .cleanup = via_playback_pcm_cleanup
1531         },
1532 };
1533
1534 static struct hda_pcm_stream vt1709_6ch_pcm_analog_playback = {
1535         .substreams = 1,
1536         .channels_min = 2,
1537         .channels_max = 6,
1538         .nid = 0x10, /* NID to query formats and rates */
1539         .ops = {
1540                 .open = via_playback_pcm_open,
1541                 .prepare = via_playback_pcm_prepare,
1542                 .cleanup = via_playback_pcm_cleanup
1543         },
1544 };
1545
1546 static struct hda_pcm_stream vt1709_pcm_analog_capture = {
1547         .substreams = 2,
1548         .channels_min = 2,
1549         .channels_max = 2,
1550         .nid = 0x14, /* NID to query formats and rates */
1551         .ops = {
1552                 .prepare = via_capture_pcm_prepare,
1553                 .cleanup = via_capture_pcm_cleanup
1554         },
1555 };
1556
1557 static struct hda_pcm_stream vt1709_pcm_digital_playback = {
1558         .substreams = 1,
1559         .channels_min = 2,
1560         .channels_max = 2,
1561         /* NID is set in via_build_pcms */
1562         .ops = {
1563                 .open = via_dig_playback_pcm_open,
1564                 .close = via_dig_playback_pcm_close
1565         },
1566 };
1567
1568 static struct hda_pcm_stream vt1709_pcm_digital_capture = {
1569         .substreams = 1,
1570         .channels_min = 2,
1571         .channels_max = 2,
1572 };
1573
1574 static int vt1709_auto_fill_dac_nids(struct via_spec *spec,
1575                                      const struct auto_pin_cfg *cfg)
1576 {
1577         int i;
1578         hda_nid_t nid;
1579
1580         if (cfg->line_outs == 4)  /* 10 channels */
1581                 spec->multiout.num_dacs = cfg->line_outs+1; /* AOW0~AOW4 */
1582         else if (cfg->line_outs == 3) /* 6 channels */
1583                 spec->multiout.num_dacs = cfg->line_outs; /* AOW0~AOW2 */
1584
1585         spec->multiout.dac_nids = spec->private_dac_nids;
1586
1587         if (cfg->line_outs == 4) { /* 10 channels */
1588                 for (i = 0; i < cfg->line_outs; i++) {
1589                         nid = cfg->line_out_pins[i];
1590                         if (nid) {
1591                                 /* config dac list */
1592                                 switch (i) {
1593                                 case AUTO_SEQ_FRONT:
1594                                         /* AOW0 */
1595                                         spec->multiout.dac_nids[i] = 0x10;
1596                                         break;
1597                                 case AUTO_SEQ_CENLFE:
1598                                         /* AOW2 */
1599                                         spec->multiout.dac_nids[i] = 0x12;
1600                                         break;
1601                                 case AUTO_SEQ_SURROUND:
1602                                         /* AOW3 */
1603                                         spec->multiout.dac_nids[i] = 0x11;
1604                                         break;
1605                                 case AUTO_SEQ_SIDE:
1606                                         /* AOW1 */
1607                                         spec->multiout.dac_nids[i] = 0x27;
1608                                         break;
1609                                 default:
1610                                         break;
1611                                 }
1612                         }
1613                 }
1614                 spec->multiout.dac_nids[cfg->line_outs] = 0x28; /* AOW4 */
1615
1616         } else if (cfg->line_outs == 3) { /* 6 channels */
1617                 for(i = 0; i < cfg->line_outs; i++) {
1618                         nid = cfg->line_out_pins[i];
1619                         if (nid) {
1620                                 /* config dac list */
1621                                 switch(i) {
1622                                 case AUTO_SEQ_FRONT:
1623                                         /* AOW0 */
1624                                         spec->multiout.dac_nids[i] = 0x10;
1625                                         break;
1626                                 case AUTO_SEQ_CENLFE:
1627                                         /* AOW2 */
1628                                         spec->multiout.dac_nids[i] = 0x12;
1629                                         break;
1630                                 case AUTO_SEQ_SURROUND:
1631                                         /* AOW1 */
1632                                         spec->multiout.dac_nids[i] = 0x11;
1633                                         break;
1634                                 default:
1635                                         break;
1636                                 }
1637                         }
1638                 }
1639         }
1640
1641         return 0;
1642 }
1643
1644 /* add playback controls from the parsed DAC table */
1645 static int vt1709_auto_create_multi_out_ctls(struct via_spec *spec,
1646                                              const struct auto_pin_cfg *cfg)
1647 {
1648         char name[32];
1649         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
1650         hda_nid_t nid = 0;
1651         int i, err;
1652
1653         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
1654                 nid = cfg->line_out_pins[i];
1655
1656                 if (!nid)
1657                         continue;
1658
1659                 if (i == AUTO_SEQ_CENLFE) {
1660                         /* Center/LFE */
1661                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1662                                               "Center Playback Volume",
1663                                               HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1664                                                                   HDA_OUTPUT));
1665                         if (err < 0)
1666                                 return err;
1667                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1668                                               "LFE Playback Volume",
1669                                               HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1670                                                                   HDA_OUTPUT));
1671                         if (err < 0)
1672                                 return err;
1673                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1674                                               "Center Playback Switch",
1675                                               HDA_COMPOSE_AMP_VAL(0x1b, 1, 0,
1676                                                                   HDA_OUTPUT));
1677                         if (err < 0)
1678                                 return err;
1679                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1680                                               "LFE Playback Switch",
1681                                               HDA_COMPOSE_AMP_VAL(0x1b, 2, 0,
1682                                                                   HDA_OUTPUT));
1683                         if (err < 0)
1684                                 return err;
1685                 } else if (i == AUTO_SEQ_FRONT){
1686                         /* add control to mixer index 0 */
1687                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1688                                               "Master Front Playback Volume",
1689                                               HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1690                                                                   HDA_INPUT));
1691                         if (err < 0)
1692                                 return err;
1693                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1694                                               "Master Front Playback Switch",
1695                                               HDA_COMPOSE_AMP_VAL(0x18, 3, 0,
1696                                                                   HDA_INPUT));
1697                         if (err < 0)
1698                                 return err;
1699
1700                         /* add control to PW3 */
1701                         sprintf(name, "%s Playback Volume", chname[i]);
1702                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1703                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1704                                                                   HDA_OUTPUT));
1705                         if (err < 0)
1706                                 return err;
1707                         sprintf(name, "%s Playback Switch", chname[i]);
1708                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1709                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
1710                                                                   HDA_OUTPUT));
1711                         if (err < 0)
1712                                 return err;
1713                 } else if (i == AUTO_SEQ_SURROUND) {
1714                         sprintf(name, "%s Playback Volume", chname[i]);
1715                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1716                                               HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1717                                                                   HDA_OUTPUT));
1718                         if (err < 0)
1719                                 return err;
1720                         sprintf(name, "%s Playback Switch", chname[i]);
1721                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1722                                               HDA_COMPOSE_AMP_VAL(0x1a, 3, 0,
1723                                                                   HDA_OUTPUT));
1724                         if (err < 0)
1725                                 return err;
1726                 } else if (i == AUTO_SEQ_SIDE) {
1727                         sprintf(name, "%s Playback Volume", chname[i]);
1728                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
1729                                               HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1730                                                                   HDA_OUTPUT));
1731                         if (err < 0)
1732                                 return err;
1733                         sprintf(name, "%s Playback Switch", chname[i]);
1734                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
1735                                               HDA_COMPOSE_AMP_VAL(0x29, 3, 0,
1736                                                                   HDA_OUTPUT));
1737                         if (err < 0)
1738                                 return err;
1739                 }
1740         }
1741
1742         return 0;
1743 }
1744
1745 static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
1746 {
1747         int err;
1748
1749         if (!pin)
1750                 return 0;
1751
1752         if (spec->multiout.num_dacs == 5) /* 10 channels */
1753                 spec->multiout.hp_nid = VT1709_HP_DAC_NID;
1754         else if (spec->multiout.num_dacs == 3) /* 6 channels */
1755                 spec->multiout.hp_nid = 0;
1756
1757         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
1758                               "Headphone Playback Volume",
1759                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1760         if (err < 0)
1761                 return err;
1762         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
1763                               "Headphone Playback Switch",
1764                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
1765         if (err < 0)
1766                 return err;
1767
1768         return 0;
1769 }
1770
1771 /* create playback/capture controls for input pins */
1772 static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec,
1773                                                 const struct auto_pin_cfg *cfg)
1774 {
1775         static char *labels[] = {
1776                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
1777         };
1778         struct hda_input_mux *imux = &spec->private_imux[0];
1779         int i, err, idx = 0;
1780
1781         /* for internal loopback recording select */
1782         imux->items[imux->num_items].label = "Stereo Mixer";
1783         imux->items[imux->num_items].index = idx;
1784         imux->num_items++;
1785
1786         for (i = 0; i < AUTO_PIN_LAST; i++) {
1787                 if (!cfg->input_pins[i])
1788                         continue;
1789
1790                 switch (cfg->input_pins[i]) {
1791                 case 0x1d: /* Mic */
1792                         idx = 2;
1793                         break;
1794
1795                 case 0x1e: /* Line In */
1796                         idx = 3;
1797                         break;
1798
1799                 case 0x21: /* Front Mic */
1800                         idx = 4;
1801                         break;
1802
1803                 case 0x23: /* CD */
1804                         idx = 1;
1805                         break;
1806                 }
1807                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
1808                                            idx, 0x18);
1809                 if (err < 0)
1810                         return err;
1811                 imux->items[imux->num_items].label = labels[i];
1812                 imux->items[imux->num_items].index = idx;
1813                 imux->num_items++;
1814         }
1815         return 0;
1816 }
1817
1818 static int vt1709_parse_auto_config(struct hda_codec *codec)
1819 {
1820         struct via_spec *spec = codec->spec;
1821         int err;
1822
1823         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1824         if (err < 0)
1825                 return err;
1826         err = vt1709_auto_fill_dac_nids(spec, &spec->autocfg);
1827         if (err < 0)
1828                 return err;
1829         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
1830                 return 0; /* can't find valid BIOS pin config */
1831
1832         err = vt1709_auto_create_multi_out_ctls(spec, &spec->autocfg);
1833         if (err < 0)
1834                 return err;
1835         err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
1836         if (err < 0)
1837                 return err;
1838         err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg);
1839         if (err < 0)
1840                 return err;
1841
1842         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
1843
1844         if (spec->autocfg.dig_out_pin)
1845                 spec->multiout.dig_out_nid = VT1709_DIGOUT_NID;
1846         if (spec->autocfg.dig_in_pin)
1847                 spec->dig_in_nid = VT1709_DIGIN_NID;
1848
1849         if (spec->kctl_alloc)
1850                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
1851
1852         spec->input_mux = &spec->private_imux[0];
1853
1854         if (spec->hp_mux)
1855                 spec->mixers[spec->num_mixers++] = via_hp_mixer;
1856
1857         return 1;
1858 }
1859
1860 #ifdef CONFIG_SND_HDA_POWER_SAVE
1861 static struct hda_amp_list vt1709_loopbacks[] = {
1862         { 0x18, HDA_INPUT, 1 },
1863         { 0x18, HDA_INPUT, 2 },
1864         { 0x18, HDA_INPUT, 3 },
1865         { 0x18, HDA_INPUT, 4 },
1866         { } /* end */
1867 };
1868 #endif
1869
1870 static int patch_vt1709_10ch(struct hda_codec *codec)
1871 {
1872         struct via_spec *spec;
1873         int err;
1874
1875         /* create a codec specific record */
1876         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1877         if (spec == NULL)
1878                 return -ENOMEM;
1879
1880         codec->spec = spec;
1881
1882         err = vt1709_parse_auto_config(codec);
1883         if (err < 0) {
1884                 via_free(codec);
1885                 return err;
1886         } else if (!err) {
1887                 printk(KERN_INFO "hda_codec: Cannot set up configuration.  "
1888                        "Using genenic mode...\n");
1889         }
1890
1891         spec->init_verbs[spec->num_iverbs++] = vt1709_10ch_volume_init_verbs;
1892         spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
1893
1894         spec->stream_name_analog = "VT1709 Analog";
1895         spec->stream_analog_playback = &vt1709_10ch_pcm_analog_playback;
1896         spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1897
1898         spec->stream_name_digital = "VT1709 Digital";
1899         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1900         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1901
1902
1903         if (!spec->adc_nids && spec->input_mux) {
1904                 spec->adc_nids = vt1709_adc_nids;
1905                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1906                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
1907                 spec->num_mixers++;
1908         }
1909
1910         codec->patch_ops = via_patch_ops;
1911
1912         codec->patch_ops.init = via_auto_init;
1913         codec->patch_ops.unsol_event = via_unsol_event;
1914 #ifdef CONFIG_SND_HDA_POWER_SAVE
1915         spec->loopback.amplist = vt1709_loopbacks;
1916 #endif
1917
1918         return 0;
1919 }
1920 /*
1921  * generic initialization of ADC, input mixers and output mixers
1922  */
1923 static struct hda_verb vt1709_6ch_volume_init_verbs[] = {
1924         /*
1925          * Unmute ADC0-2 and set the default input to mic-in
1926          */
1927         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1928         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1929         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1930
1931
1932         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
1933          * mixer widget
1934          */
1935         /* Amp Indices: AOW0=0, CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
1936         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1937         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1938         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
1939         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
1940         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
1941
1942         /*
1943          * Set up output selector (0x1a, 0x1b, 0x29)
1944          */
1945         /* set vol=0 to output mixers */
1946         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1947         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1948         {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1949
1950         /*
1951          *  Unmute PW3 and PW4
1952          */
1953         {0x1f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1954         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
1955
1956         /* Set input of PW4 as MW0 */
1957         {0x20, AC_VERB_SET_CONNECT_SEL, 0},
1958         /* PW9 Output enable */
1959         {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
1960         { }
1961 };
1962
1963 static int patch_vt1709_6ch(struct hda_codec *codec)
1964 {
1965         struct via_spec *spec;
1966         int err;
1967
1968         /* create a codec specific record */
1969         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1970         if (spec == NULL)
1971                 return -ENOMEM;
1972
1973         codec->spec = spec;
1974
1975         err = vt1709_parse_auto_config(codec);
1976         if (err < 0) {
1977                 via_free(codec);
1978                 return err;
1979         } else if (!err) {
1980                 printk(KERN_INFO "hda_codec: Cannot set up configuration.  "
1981                        "Using genenic mode...\n");
1982         }
1983
1984         spec->init_verbs[spec->num_iverbs++] = vt1709_6ch_volume_init_verbs;
1985         spec->init_verbs[spec->num_iverbs++] = vt1709_uniwill_init_verbs;
1986
1987         spec->stream_name_analog = "VT1709 Analog";
1988         spec->stream_analog_playback = &vt1709_6ch_pcm_analog_playback;
1989         spec->stream_analog_capture = &vt1709_pcm_analog_capture;
1990
1991         spec->stream_name_digital = "VT1709 Digital";
1992         spec->stream_digital_playback = &vt1709_pcm_digital_playback;
1993         spec->stream_digital_capture = &vt1709_pcm_digital_capture;
1994
1995
1996         if (!spec->adc_nids && spec->input_mux) {
1997                 spec->adc_nids = vt1709_adc_nids;
1998                 spec->num_adc_nids = ARRAY_SIZE(vt1709_adc_nids);
1999                 spec->mixers[spec->num_mixers] = vt1709_capture_mixer;
2000                 spec->num_mixers++;
2001         }
2002
2003         codec->patch_ops = via_patch_ops;
2004
2005         codec->patch_ops.init = via_auto_init;
2006         codec->patch_ops.unsol_event = via_unsol_event;
2007 #ifdef CONFIG_SND_HDA_POWER_SAVE
2008         spec->loopback.amplist = vt1709_loopbacks;
2009 #endif
2010         return 0;
2011 }
2012
2013 /* capture mixer elements */
2014 static struct snd_kcontrol_new vt1708B_capture_mixer[] = {
2015         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
2016         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
2017         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
2018         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
2019         {
2020                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2021                 /* The multiple "Capture Source" controls confuse alsamixer
2022                  * So call somewhat different..
2023                  */
2024                 /* .name = "Capture Source", */
2025                 .name = "Input Source",
2026                 .count = 1,
2027                 .info = via_mux_enum_info,
2028                 .get = via_mux_enum_get,
2029                 .put = via_mux_enum_put,
2030         },
2031         { } /* end */
2032 };
2033 /*
2034  * generic initialization of ADC, input mixers and output mixers
2035  */
2036 static struct hda_verb vt1708B_8ch_volume_init_verbs[] = {
2037         /*
2038          * Unmute ADC0-1 and set the default input to mic-in
2039          */
2040         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2041         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2042
2043
2044         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2045          * mixer widget
2046          */
2047         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2048         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2049         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2050         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2051         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2052         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2053
2054         /*
2055          * Set up output mixers
2056          */
2057         /* set vol=0 to output mixers */
2058         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2059         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2060         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2061
2062         /* Setup default input to PW4 */
2063         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x1},
2064         /* PW9 Output enable */
2065         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2066         /* PW10 Input enable */
2067         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2068         { }
2069 };
2070
2071 static struct hda_verb vt1708B_4ch_volume_init_verbs[] = {
2072         /*
2073          * Unmute ADC0-1 and set the default input to mic-in
2074          */
2075         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2076         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2077
2078
2079         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2080          * mixer widget
2081          */
2082         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2083         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2084         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2085         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2086         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2087         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2088
2089         /*
2090          * Set up output mixers
2091          */
2092         /* set vol=0 to output mixers */
2093         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2094         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2095         {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2096
2097         /* Setup default input of PW4 to MW0 */
2098         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2099         /* PW9 Output enable */
2100         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2101         /* PW10 Input enable */
2102         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
2103         { }
2104 };
2105
2106 static struct hda_verb vt1708B_uniwill_init_verbs[] = {
2107         {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2108         { }
2109 };
2110
2111 static struct hda_pcm_stream vt1708B_8ch_pcm_analog_playback = {
2112         .substreams = 2,
2113         .channels_min = 2,
2114         .channels_max = 8,
2115         .nid = 0x10, /* NID to query formats and rates */
2116         .ops = {
2117                 .open = via_playback_pcm_open,
2118                 .prepare = via_playback_multi_pcm_prepare,
2119                 .cleanup = via_playback_multi_pcm_cleanup
2120         },
2121 };
2122
2123 static struct hda_pcm_stream vt1708B_4ch_pcm_analog_playback = {
2124         .substreams = 2,
2125         .channels_min = 2,
2126         .channels_max = 4,
2127         .nid = 0x10, /* NID to query formats and rates */
2128         .ops = {
2129                 .open = via_playback_pcm_open,
2130                 .prepare = via_playback_multi_pcm_prepare,
2131                 .cleanup = via_playback_multi_pcm_cleanup
2132         },
2133 };
2134
2135 static struct hda_pcm_stream vt1708B_pcm_analog_capture = {
2136         .substreams = 2,
2137         .channels_min = 2,
2138         .channels_max = 2,
2139         .nid = 0x13, /* NID to query formats and rates */
2140         .ops = {
2141                 .prepare = via_capture_pcm_prepare,
2142                 .cleanup = via_capture_pcm_cleanup
2143         },
2144 };
2145
2146 static struct hda_pcm_stream vt1708B_pcm_digital_playback = {
2147         .substreams = 1,
2148         .channels_min = 2,
2149         .channels_max = 2,
2150         /* NID is set in via_build_pcms */
2151         .ops = {
2152                 .open = via_dig_playback_pcm_open,
2153                 .close = via_dig_playback_pcm_close,
2154                 .prepare = via_dig_playback_pcm_prepare
2155         },
2156 };
2157
2158 static struct hda_pcm_stream vt1708B_pcm_digital_capture = {
2159         .substreams = 1,
2160         .channels_min = 2,
2161         .channels_max = 2,
2162 };
2163
2164 /* fill in the dac_nids table from the parsed pin configuration */
2165 static int vt1708B_auto_fill_dac_nids(struct via_spec *spec,
2166                                      const struct auto_pin_cfg *cfg)
2167 {
2168         int i;
2169         hda_nid_t nid;
2170
2171         spec->multiout.num_dacs = cfg->line_outs;
2172
2173         spec->multiout.dac_nids = spec->private_dac_nids;
2174
2175         for (i = 0; i < 4; i++) {
2176                 nid = cfg->line_out_pins[i];
2177                 if (nid) {
2178                         /* config dac list */
2179                         switch (i) {
2180                         case AUTO_SEQ_FRONT:
2181                                 spec->multiout.dac_nids[i] = 0x10;
2182                                 break;
2183                         case AUTO_SEQ_CENLFE:
2184                                 spec->multiout.dac_nids[i] = 0x24;
2185                                 break;
2186                         case AUTO_SEQ_SURROUND:
2187                                 spec->multiout.dac_nids[i] = 0x11;
2188                                 break;
2189                         case AUTO_SEQ_SIDE:
2190                                 spec->multiout.dac_nids[i] = 0x25;
2191                                 break;
2192                         }
2193                 }
2194         }
2195
2196         return 0;
2197 }
2198
2199 /* add playback controls from the parsed DAC table */
2200 static int vt1708B_auto_create_multi_out_ctls(struct via_spec *spec,
2201                                              const struct auto_pin_cfg *cfg)
2202 {
2203         char name[32];
2204         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2205         hda_nid_t nid_vols[] = {0x16, 0x18, 0x26, 0x27};
2206         hda_nid_t nid, nid_vol = 0;
2207         int i, err;
2208
2209         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2210                 nid = cfg->line_out_pins[i];
2211
2212                 if (!nid)
2213                         continue;
2214
2215                 nid_vol = nid_vols[i];
2216
2217                 if (i == AUTO_SEQ_CENLFE) {
2218                         /* Center/LFE */
2219                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2220                                               "Center Playback Volume",
2221                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2222                                                                   HDA_OUTPUT));
2223                         if (err < 0)
2224                                 return err;
2225                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2226                                               "LFE Playback Volume",
2227                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2228                                                                   HDA_OUTPUT));
2229                         if (err < 0)
2230                                 return err;
2231                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2232                                               "Center Playback Switch",
2233                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2234                                                                   HDA_OUTPUT));
2235                         if (err < 0)
2236                                 return err;
2237                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2238                                               "LFE Playback Switch",
2239                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2240                                                                   HDA_OUTPUT));
2241                         if (err < 0)
2242                                 return err;
2243                 } else if (i == AUTO_SEQ_FRONT) {
2244                         /* add control to mixer index 0 */
2245                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2246                                               "Master Front Playback Volume",
2247                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2248                                                                   HDA_INPUT));
2249                         if (err < 0)
2250                                 return err;
2251                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2252                                               "Master Front Playback Switch",
2253                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2254                                                                   HDA_INPUT));
2255                         if (err < 0)
2256                                 return err;
2257
2258                         /* add control to PW3 */
2259                         sprintf(name, "%s Playback Volume", chname[i]);
2260                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2261                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2262                                                                   HDA_OUTPUT));
2263                         if (err < 0)
2264                                 return err;
2265                         sprintf(name, "%s Playback Switch", chname[i]);
2266                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2267                                               HDA_COMPOSE_AMP_VAL(nid, 3, 0,
2268                                                                   HDA_OUTPUT));
2269                         if (err < 0)
2270                                 return err;
2271                 } else {
2272                         sprintf(name, "%s Playback Volume", chname[i]);
2273                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2274                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2275                                                                   HDA_OUTPUT));
2276                         if (err < 0)
2277                                 return err;
2278                         sprintf(name, "%s Playback Switch", chname[i]);
2279                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2280                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2281                                                                   HDA_OUTPUT));
2282                         if (err < 0)
2283                                 return err;
2284                 }
2285         }
2286
2287         return 0;
2288 }
2289
2290 static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2291 {
2292         int err;
2293
2294         if (!pin)
2295                 return 0;
2296
2297         spec->multiout.hp_nid = VT1708B_HP_NID; /* AOW3 */
2298
2299         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2300                               "Headphone Playback Volume",
2301                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2302         if (err < 0)
2303                 return err;
2304         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2305                               "Headphone Playback Switch",
2306                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2307         if (err < 0)
2308                 return err;
2309
2310         create_hp_imux(spec);
2311
2312         return 0;
2313 }
2314
2315 /* create playback/capture controls for input pins */
2316 static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec,
2317                                                 const struct auto_pin_cfg *cfg)
2318 {
2319         static char *labels[] = {
2320                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2321         };
2322         struct hda_input_mux *imux = &spec->private_imux[0];
2323         int i, err, idx = 0;
2324
2325         /* for internal loopback recording select */
2326         imux->items[imux->num_items].label = "Stereo Mixer";
2327         imux->items[imux->num_items].index = idx;
2328         imux->num_items++;
2329
2330         for (i = 0; i < AUTO_PIN_LAST; i++) {
2331                 if (!cfg->input_pins[i])
2332                         continue;
2333
2334                 switch (cfg->input_pins[i]) {
2335                 case 0x1a: /* Mic */
2336                         idx = 2;
2337                         break;
2338
2339                 case 0x1b: /* Line In */
2340                         idx = 3;
2341                         break;
2342
2343                 case 0x1e: /* Front Mic */
2344                         idx = 4;
2345                         break;
2346
2347                 case 0x1f: /* CD */
2348                         idx = 1;
2349                         break;
2350                 }
2351                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2352                                            idx, 0x16);
2353                 if (err < 0)
2354                         return err;
2355                 imux->items[imux->num_items].label = labels[i];
2356                 imux->items[imux->num_items].index = idx;
2357                 imux->num_items++;
2358         }
2359         return 0;
2360 }
2361
2362 static int vt1708B_parse_auto_config(struct hda_codec *codec)
2363 {
2364         struct via_spec *spec = codec->spec;
2365         int err;
2366
2367         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
2368         if (err < 0)
2369                 return err;
2370         err = vt1708B_auto_fill_dac_nids(spec, &spec->autocfg);
2371         if (err < 0)
2372                 return err;
2373         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2374                 return 0; /* can't find valid BIOS pin config */
2375
2376         err = vt1708B_auto_create_multi_out_ctls(spec, &spec->autocfg);
2377         if (err < 0)
2378                 return err;
2379         err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2380         if (err < 0)
2381                 return err;
2382         err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg);
2383         if (err < 0)
2384                 return err;
2385
2386         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2387
2388         if (spec->autocfg.dig_out_pin)
2389                 spec->multiout.dig_out_nid = VT1708B_DIGOUT_NID;
2390         if (spec->autocfg.dig_in_pin)
2391                 spec->dig_in_nid = VT1708B_DIGIN_NID;
2392
2393         if (spec->kctl_alloc)
2394                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2395
2396         spec->input_mux = &spec->private_imux[0];
2397
2398         if (spec->hp_mux)
2399                 spec->mixers[spec->num_mixers++] = via_hp_mixer;
2400
2401         return 1;
2402 }
2403
2404 #ifdef CONFIG_SND_HDA_POWER_SAVE
2405 static struct hda_amp_list vt1708B_loopbacks[] = {
2406         { 0x16, HDA_INPUT, 1 },
2407         { 0x16, HDA_INPUT, 2 },
2408         { 0x16, HDA_INPUT, 3 },
2409         { 0x16, HDA_INPUT, 4 },
2410         { } /* end */
2411 };
2412 #endif
2413
2414 static int patch_vt1708B_8ch(struct hda_codec *codec)
2415 {
2416         struct via_spec *spec;
2417         int err;
2418
2419         /* create a codec specific record */
2420         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2421         if (spec == NULL)
2422                 return -ENOMEM;
2423
2424         codec->spec = spec;
2425
2426         /* automatic parse from the BIOS config */
2427         err = vt1708B_parse_auto_config(codec);
2428         if (err < 0) {
2429                 via_free(codec);
2430                 return err;
2431         } else if (!err) {
2432                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2433                        "from BIOS.  Using genenic mode...\n");
2434         }
2435
2436         spec->init_verbs[spec->num_iverbs++] = vt1708B_8ch_volume_init_verbs;
2437         spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
2438
2439         spec->stream_name_analog = "VT1708B Analog";
2440         spec->stream_analog_playback = &vt1708B_8ch_pcm_analog_playback;
2441         spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2442
2443         spec->stream_name_digital = "VT1708B Digital";
2444         spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2445         spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2446
2447         if (!spec->adc_nids && spec->input_mux) {
2448                 spec->adc_nids = vt1708B_adc_nids;
2449                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2450                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2451                 spec->num_mixers++;
2452         }
2453
2454         codec->patch_ops = via_patch_ops;
2455
2456         codec->patch_ops.init = via_auto_init;
2457         codec->patch_ops.unsol_event = via_unsol_event;
2458 #ifdef CONFIG_SND_HDA_POWER_SAVE
2459         spec->loopback.amplist = vt1708B_loopbacks;
2460 #endif
2461
2462         return 0;
2463 }
2464
2465 static int patch_vt1708B_4ch(struct hda_codec *codec)
2466 {
2467         struct via_spec *spec;
2468         int err;
2469
2470         /* create a codec specific record */
2471         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2472         if (spec == NULL)
2473                 return -ENOMEM;
2474
2475         codec->spec = spec;
2476
2477         /* automatic parse from the BIOS config */
2478         err = vt1708B_parse_auto_config(codec);
2479         if (err < 0) {
2480                 via_free(codec);
2481                 return err;
2482         } else if (!err) {
2483                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2484                        "from BIOS.  Using genenic mode...\n");
2485         }
2486
2487         spec->init_verbs[spec->num_iverbs++] = vt1708B_4ch_volume_init_verbs;
2488         spec->init_verbs[spec->num_iverbs++] = vt1708B_uniwill_init_verbs;
2489
2490         spec->stream_name_analog = "VT1708B Analog";
2491         spec->stream_analog_playback = &vt1708B_4ch_pcm_analog_playback;
2492         spec->stream_analog_capture = &vt1708B_pcm_analog_capture;
2493
2494         spec->stream_name_digital = "VT1708B Digital";
2495         spec->stream_digital_playback = &vt1708B_pcm_digital_playback;
2496         spec->stream_digital_capture = &vt1708B_pcm_digital_capture;
2497
2498         if (!spec->adc_nids && spec->input_mux) {
2499                 spec->adc_nids = vt1708B_adc_nids;
2500                 spec->num_adc_nids = ARRAY_SIZE(vt1708B_adc_nids);
2501                 spec->mixers[spec->num_mixers] = vt1708B_capture_mixer;
2502                 spec->num_mixers++;
2503         }
2504
2505         codec->patch_ops = via_patch_ops;
2506
2507         codec->patch_ops.init = via_auto_init;
2508         codec->patch_ops.unsol_event = via_unsol_event;
2509 #ifdef CONFIG_SND_HDA_POWER_SAVE
2510         spec->loopback.amplist = vt1708B_loopbacks;
2511 #endif
2512
2513         return 0;
2514 }
2515
2516 /* Patch for VT1708S */
2517
2518 /* VT1708S software backdoor based override for buggy hardware micboost
2519  * setting */
2520 #define MIC_BOOST_VOLUME(xname, nid) {                          \
2521         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
2522         .name = xname,                                  \
2523         .index = 0,                                     \
2524         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |     \
2525         SNDRV_CTL_ELEM_ACCESS_TLV_READ |                \
2526         SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK,             \
2527         .info = mic_boost_volume_info,                  \
2528         .get = snd_hda_mixer_amp_volume_get,            \
2529         .put = snd_hda_mixer_amp_volume_put,            \
2530         .tlv = { .c = mic_boost_tlv },                  \
2531         .private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT) }
2532
2533 /* capture mixer elements */
2534 static struct snd_kcontrol_new vt1708S_capture_mixer[] = {
2535         HDA_CODEC_VOLUME("Capture Volume", 0x13, 0x0, HDA_INPUT),
2536         HDA_CODEC_MUTE("Capture Switch", 0x13, 0x0, HDA_INPUT),
2537         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x14, 0x0, HDA_INPUT),
2538         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x14, 0x0, HDA_INPUT),
2539         MIC_BOOST_VOLUME("Mic Boost Capture Volume", 0x1A),
2540         MIC_BOOST_VOLUME("Front Mic Boost Capture Volume", 0x1E),
2541         {
2542                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2543                 /* The multiple "Capture Source" controls confuse alsamixer
2544                  * So call somewhat different..
2545                  */
2546                 /* .name = "Capture Source", */
2547                 .name = "Input Source",
2548                 .count = 1,
2549                 .info = via_mux_enum_info,
2550                 .get = via_mux_enum_get,
2551                 .put = via_mux_enum_put,
2552         },
2553         { } /* end */
2554 };
2555
2556 static struct hda_verb vt1708S_volume_init_verbs[] = {
2557         /* Unmute ADC0-1 and set the default input to mic-in */
2558         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2559         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2560
2561         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the
2562          * analog-loopback mixer widget */
2563         /* Amp Indices: CD = 1, Mic1 = 2, Line = 3, Mic2 = 4 */
2564         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2565         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2566         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2567         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2568         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
2569
2570         /* Setup default input of PW4 to MW0 */
2571         {0x1d, AC_VERB_SET_CONNECT_SEL, 0x0},
2572         /* PW9, PW10  Output enable */
2573         {0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2574         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2575         /* Enable Mic Boost Volume backdoor */
2576         {0x1, 0xf98, 0x1},
2577         { }
2578 };
2579
2580 static struct hda_verb vt1708S_uniwill_init_verbs[] = {
2581         {0x1D, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2582         { }
2583 };
2584
2585 static struct hda_pcm_stream vt1708S_pcm_analog_playback = {
2586         .substreams = 2,
2587         .channels_min = 2,
2588         .channels_max = 8,
2589         .nid = 0x10, /* NID to query formats and rates */
2590         .ops = {
2591                 .open = via_playback_pcm_open,
2592                 .prepare = via_playback_pcm_prepare,
2593                 .cleanup = via_playback_pcm_cleanup
2594         },
2595 };
2596
2597 static struct hda_pcm_stream vt1708S_pcm_analog_capture = {
2598         .substreams = 2,
2599         .channels_min = 2,
2600         .channels_max = 2,
2601         .nid = 0x13, /* NID to query formats and rates */
2602         .ops = {
2603                 .prepare = via_capture_pcm_prepare,
2604                 .cleanup = via_capture_pcm_cleanup
2605         },
2606 };
2607
2608 static struct hda_pcm_stream vt1708S_pcm_digital_playback = {
2609         .substreams = 2,
2610         .channels_min = 2,
2611         .channels_max = 2,
2612         /* NID is set in via_build_pcms */
2613         .ops = {
2614                 .open = via_dig_playback_pcm_open,
2615                 .close = via_dig_playback_pcm_close,
2616                 .prepare = via_dig_playback_pcm_prepare
2617         },
2618 };
2619
2620 /* fill in the dac_nids table from the parsed pin configuration */
2621 static int vt1708S_auto_fill_dac_nids(struct via_spec *spec,
2622                                      const struct auto_pin_cfg *cfg)
2623 {
2624         int i;
2625         hda_nid_t nid;
2626
2627         spec->multiout.num_dacs = cfg->line_outs;
2628
2629         spec->multiout.dac_nids = spec->private_dac_nids;
2630
2631         for (i = 0; i < 4; i++) {
2632                 nid = cfg->line_out_pins[i];
2633                 if (nid) {
2634                         /* config dac list */
2635                         switch (i) {
2636                         case AUTO_SEQ_FRONT:
2637                                 spec->multiout.dac_nids[i] = 0x10;
2638                                 break;
2639                         case AUTO_SEQ_CENLFE:
2640                                 spec->multiout.dac_nids[i] = 0x24;
2641                                 break;
2642                         case AUTO_SEQ_SURROUND:
2643                                 spec->multiout.dac_nids[i] = 0x11;
2644                                 break;
2645                         case AUTO_SEQ_SIDE:
2646                                 spec->multiout.dac_nids[i] = 0x25;
2647                                 break;
2648                         }
2649                 }
2650         }
2651
2652         return 0;
2653 }
2654
2655 /* add playback controls from the parsed DAC table */
2656 static int vt1708S_auto_create_multi_out_ctls(struct via_spec *spec,
2657                                              const struct auto_pin_cfg *cfg)
2658 {
2659         char name[32];
2660         static const char *chname[4] = { "Front", "Surround", "C/LFE", "Side" };
2661         hda_nid_t nid_vols[] = {0x10, 0x11, 0x24, 0x25};
2662         hda_nid_t nid_mutes[] = {0x1C, 0x18, 0x26, 0x27};
2663         hda_nid_t nid, nid_vol, nid_mute;
2664         int i, err;
2665
2666         for (i = 0; i <= AUTO_SEQ_SIDE; i++) {
2667                 nid = cfg->line_out_pins[i];
2668
2669                 if (!nid)
2670                         continue;
2671
2672                 nid_vol = nid_vols[i];
2673                 nid_mute = nid_mutes[i];
2674
2675                 if (i == AUTO_SEQ_CENLFE) {
2676                         /* Center/LFE */
2677                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2678                                               "Center Playback Volume",
2679                                               HDA_COMPOSE_AMP_VAL(nid_vol, 1, 0,
2680                                                                   HDA_OUTPUT));
2681                         if (err < 0)
2682                                 return err;
2683                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2684                                               "LFE Playback Volume",
2685                                               HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0,
2686                                                                   HDA_OUTPUT));
2687                         if (err < 0)
2688                                 return err;
2689                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2690                                               "Center Playback Switch",
2691                                               HDA_COMPOSE_AMP_VAL(nid_mute,
2692                                                                   1, 0,
2693                                                                   HDA_OUTPUT));
2694                         if (err < 0)
2695                                 return err;
2696                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2697                                               "LFE Playback Switch",
2698                                               HDA_COMPOSE_AMP_VAL(nid_mute,
2699                                                                   2, 0,
2700                                                                   HDA_OUTPUT));
2701                         if (err < 0)
2702                                 return err;
2703                 } else if (i == AUTO_SEQ_FRONT) {
2704                         /* add control to mixer index 0 */
2705                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2706                                               "Master Front Playback Volume",
2707                                               HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2708                                                                   HDA_INPUT));
2709                         if (err < 0)
2710                                 return err;
2711                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2712                                               "Master Front Playback Switch",
2713                                               HDA_COMPOSE_AMP_VAL(0x16, 3, 0,
2714                                                                   HDA_INPUT));
2715                         if (err < 0)
2716                                 return err;
2717
2718                         /* Front */
2719                         sprintf(name, "%s Playback Volume", chname[i]);
2720                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2721                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2722                                                                   HDA_OUTPUT));
2723                         if (err < 0)
2724                                 return err;
2725                         sprintf(name, "%s Playback Switch", chname[i]);
2726                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2727                                               HDA_COMPOSE_AMP_VAL(nid_mute,
2728                                                                   3, 0,
2729                                                                   HDA_OUTPUT));
2730                         if (err < 0)
2731                                 return err;
2732                 } else {
2733                         sprintf(name, "%s Playback Volume", chname[i]);
2734                         err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name,
2735                                               HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0,
2736                                                                   HDA_OUTPUT));
2737                         if (err < 0)
2738                                 return err;
2739                         sprintf(name, "%s Playback Switch", chname[i]);
2740                         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE, name,
2741                                               HDA_COMPOSE_AMP_VAL(nid_mute,
2742                                                                   3, 0,
2743                                                                   HDA_OUTPUT));
2744                         if (err < 0)
2745                                 return err;
2746                 }
2747         }
2748
2749         return 0;
2750 }
2751
2752 static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
2753 {
2754         int err;
2755
2756         if (!pin)
2757                 return 0;
2758
2759         spec->multiout.hp_nid = VT1708S_HP_NID; /* AOW3 */
2760
2761         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
2762                               "Headphone Playback Volume",
2763                               HDA_COMPOSE_AMP_VAL(0x25, 3, 0, HDA_OUTPUT));
2764         if (err < 0)
2765                 return err;
2766
2767         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
2768                               "Headphone Playback Switch",
2769                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
2770         if (err < 0)
2771                 return err;
2772
2773         create_hp_imux(spec);
2774
2775         return 0;
2776 }
2777
2778 /* create playback/capture controls for input pins */
2779 static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec,
2780                                                 const struct auto_pin_cfg *cfg)
2781 {
2782         static char *labels[] = {
2783                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
2784         };
2785         struct hda_input_mux *imux = &spec->private_imux[0];
2786         int i, err, idx = 0;
2787
2788         /* for internal loopback recording select */
2789         imux->items[imux->num_items].label = "Stereo Mixer";
2790         imux->items[imux->num_items].index = 5;
2791         imux->num_items++;
2792
2793         for (i = 0; i < AUTO_PIN_LAST; i++) {
2794                 if (!cfg->input_pins[i])
2795                         continue;
2796
2797                 switch (cfg->input_pins[i]) {
2798                 case 0x1a: /* Mic */
2799                         idx = 2;
2800                         break;
2801
2802                 case 0x1b: /* Line In */
2803                         idx = 3;
2804                         break;
2805
2806                 case 0x1e: /* Front Mic */
2807                         idx = 4;
2808                         break;
2809
2810                 case 0x1f: /* CD */
2811                         idx = 1;
2812                         break;
2813                 }
2814                 err = via_new_analog_input(spec, cfg->input_pins[i], labels[i],
2815                                            idx, 0x16);
2816                 if (err < 0)
2817                         return err;
2818                 imux->items[imux->num_items].label = labels[i];
2819                 imux->items[imux->num_items].index = idx-1;
2820                 imux->num_items++;
2821         }
2822         return 0;
2823 }
2824
2825 static int vt1708S_parse_auto_config(struct hda_codec *codec)
2826 {
2827         struct via_spec *spec = codec->spec;
2828         int err;
2829         static hda_nid_t vt1708s_ignore[] = {0x21, 0};
2830
2831         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
2832                                            vt1708s_ignore);
2833         if (err < 0)
2834                 return err;
2835         err = vt1708S_auto_fill_dac_nids(spec, &spec->autocfg);
2836         if (err < 0)
2837                 return err;
2838         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
2839                 return 0; /* can't find valid BIOS pin config */
2840
2841         err = vt1708S_auto_create_multi_out_ctls(spec, &spec->autocfg);
2842         if (err < 0)
2843                 return err;
2844         err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
2845         if (err < 0)
2846                 return err;
2847         err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg);
2848         if (err < 0)
2849                 return err;
2850
2851         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
2852
2853         if (spec->autocfg.dig_out_pin)
2854                 spec->multiout.dig_out_nid = VT1708S_DIGOUT_NID;
2855
2856         spec->extra_dig_out_nid = 0x15;
2857
2858         if (spec->kctl_alloc)
2859                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
2860
2861         spec->input_mux = &spec->private_imux[0];
2862
2863         if (spec->hp_mux)
2864                 spec->mixers[spec->num_mixers++] = via_hp_mixer;
2865
2866         return 1;
2867 }
2868
2869 #ifdef CONFIG_SND_HDA_POWER_SAVE
2870 static struct hda_amp_list vt1708S_loopbacks[] = {
2871         { 0x16, HDA_INPUT, 1 },
2872         { 0x16, HDA_INPUT, 2 },
2873         { 0x16, HDA_INPUT, 3 },
2874         { 0x16, HDA_INPUT, 4 },
2875         { } /* end */
2876 };
2877 #endif
2878
2879 static int patch_vt1708S(struct hda_codec *codec)
2880 {
2881         struct via_spec *spec;
2882         int err;
2883
2884         /* create a codec specific record */
2885         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2886         if (spec == NULL)
2887                 return -ENOMEM;
2888
2889         codec->spec = spec;
2890
2891         /* automatic parse from the BIOS config */
2892         err = vt1708S_parse_auto_config(codec);
2893         if (err < 0) {
2894                 via_free(codec);
2895                 return err;
2896         } else if (!err) {
2897                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
2898                        "from BIOS.  Using genenic mode...\n");
2899         }
2900
2901         spec->init_verbs[spec->num_iverbs++] = vt1708S_volume_init_verbs;
2902         spec->init_verbs[spec->num_iverbs++] = vt1708S_uniwill_init_verbs;
2903
2904         spec->stream_name_analog = "VT1708S Analog";
2905         spec->stream_analog_playback = &vt1708S_pcm_analog_playback;
2906         spec->stream_analog_capture = &vt1708S_pcm_analog_capture;
2907
2908         spec->stream_name_digital = "VT1708S Digital";
2909         spec->stream_digital_playback = &vt1708S_pcm_digital_playback;
2910
2911         if (!spec->adc_nids && spec->input_mux) {
2912                 spec->adc_nids = vt1708S_adc_nids;
2913                 spec->num_adc_nids = ARRAY_SIZE(vt1708S_adc_nids);
2914                 spec->mixers[spec->num_mixers] = vt1708S_capture_mixer;
2915                 spec->num_mixers++;
2916         }
2917
2918         codec->patch_ops = via_patch_ops;
2919
2920         codec->patch_ops.init = via_auto_init;
2921         codec->patch_ops.unsol_event = via_unsol_event;
2922 #ifdef CONFIG_SND_HDA_POWER_SAVE
2923         spec->loopback.amplist = vt1708S_loopbacks;
2924 #endif
2925
2926         return 0;
2927 }
2928
2929 /* Patch for VT1702 */
2930
2931 /* capture mixer elements */
2932 static struct snd_kcontrol_new vt1702_capture_mixer[] = {
2933         HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_INPUT),
2934         HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_INPUT),
2935         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x20, 0x0, HDA_INPUT),
2936         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x20, 0x0, HDA_INPUT),
2937         HDA_CODEC_VOLUME("Digital Mic Capture Volume", 0x1F, 0x0, HDA_INPUT),
2938         HDA_CODEC_MUTE("Digital Mic Capture Switch", 0x1F, 0x0, HDA_INPUT),
2939         HDA_CODEC_VOLUME("Digital Mic Boost Capture Volume", 0x1E, 0x0,
2940                          HDA_INPUT),
2941         {
2942                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2943                 /* The multiple "Capture Source" controls confuse alsamixer
2944                  * So call somewhat different..
2945                  */
2946                 /* .name = "Capture Source", */
2947                 .name = "Input Source",
2948                 .count = 1,
2949                 .info = via_mux_enum_info,
2950                 .get = via_mux_enum_get,
2951                 .put = via_mux_enum_put,
2952         },
2953         { } /* end */
2954 };
2955
2956 static struct hda_verb vt1702_volume_init_verbs[] = {
2957         /*
2958          * Unmute ADC0-1 and set the default input to mic-in
2959          */
2960         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2961         {0x1F, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2962         {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2963
2964
2965         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2966          * mixer widget
2967          */
2968         /* Amp Indices: Mic1 = 1, Line = 1, Mic2 = 3 */
2969         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2970         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2971         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
2972         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
2973         {0x1A, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2974
2975         /* Setup default input of PW4 to MW0 */
2976         {0x17, AC_VERB_SET_CONNECT_SEL, 0x1},
2977         /* PW6 PW7 Output enable */
2978         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2979         {0x1C, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
2980         { }
2981 };
2982
2983 static struct hda_verb vt1702_uniwill_init_verbs[] = {
2984         {0x01, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_GPIO_EVENT},
2985         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | VIA_HP_EVENT},
2986         { }
2987 };
2988
2989 static struct hda_pcm_stream vt1702_pcm_analog_playback = {
2990         .substreams = 2,
2991         .channels_min = 2,
2992         .channels_max = 2,
2993         .nid = 0x10, /* NID to query formats and rates */
2994         .ops = {
2995                 .open = via_playback_pcm_open,
2996                 .prepare = via_playback_multi_pcm_prepare,
2997                 .cleanup = via_playback_multi_pcm_cleanup
2998         },
2999 };
3000
3001 static struct hda_pcm_stream vt1702_pcm_analog_capture = {
3002         .substreams = 3,
3003         .channels_min = 2,
3004         .channels_max = 2,
3005         .nid = 0x12, /* NID to query formats and rates */
3006         .ops = {
3007                 .prepare = via_capture_pcm_prepare,
3008                 .cleanup = via_capture_pcm_cleanup
3009         },
3010 };
3011
3012 static struct hda_pcm_stream vt1702_pcm_digital_playback = {
3013         .substreams = 2,
3014         .channels_min = 2,
3015         .channels_max = 2,
3016         /* NID is set in via_build_pcms */
3017         .ops = {
3018                 .open = via_dig_playback_pcm_open,
3019                 .close = via_dig_playback_pcm_close,
3020                 .prepare = via_dig_playback_pcm_prepare
3021         },
3022 };
3023
3024 /* fill in the dac_nids table from the parsed pin configuration */
3025 static int vt1702_auto_fill_dac_nids(struct via_spec *spec,
3026                                      const struct auto_pin_cfg *cfg)
3027 {
3028         spec->multiout.num_dacs = 1;
3029         spec->multiout.dac_nids = spec->private_dac_nids;
3030
3031         if (cfg->line_out_pins[0]) {
3032                 /* config dac list */
3033                 spec->multiout.dac_nids[0] = 0x10;
3034         }
3035
3036         return 0;
3037 }
3038
3039 /* add playback controls from the parsed DAC table */
3040 static int vt1702_auto_create_line_out_ctls(struct via_spec *spec,
3041                                              const struct auto_pin_cfg *cfg)
3042 {
3043         int err;
3044
3045         if (!cfg->line_out_pins[0])
3046                 return -1;
3047
3048         /* add control to mixer index 0 */
3049         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3050                               "Master Front Playback Volume",
3051                               HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3052         if (err < 0)
3053                 return err;
3054         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3055                               "Master Front Playback Switch",
3056                               HDA_COMPOSE_AMP_VAL(0x1A, 3, 0, HDA_INPUT));
3057         if (err < 0)
3058                 return err;
3059
3060         /* Front */
3061         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3062                               "Front Playback Volume",
3063                               HDA_COMPOSE_AMP_VAL(0x10, 3, 0, HDA_OUTPUT));
3064         if (err < 0)
3065                 return err;
3066         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3067                               "Front Playback Switch",
3068                               HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT));
3069         if (err < 0)
3070                 return err;
3071
3072         return 0;
3073 }
3074
3075 static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin)
3076 {
3077         int err;
3078
3079         if (!pin)
3080                 return 0;
3081
3082         spec->multiout.hp_nid = 0x1D;
3083
3084         err = via_add_control(spec, VIA_CTL_WIDGET_VOL,
3085                               "Headphone Playback Volume",
3086                               HDA_COMPOSE_AMP_VAL(0x1D, 3, 0, HDA_OUTPUT));
3087         if (err < 0)
3088                 return err;
3089
3090         err = via_add_control(spec, VIA_CTL_WIDGET_MUTE,
3091                               "Headphone Playback Switch",
3092                               HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
3093         if (err < 0)
3094                 return err;
3095
3096         create_hp_imux(spec);
3097
3098         return 0;
3099 }
3100
3101 /* create playback/capture controls for input pins */
3102 static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec,
3103                                                 const struct auto_pin_cfg *cfg)
3104 {
3105         static char *labels[] = {
3106                 "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL
3107         };
3108         struct hda_input_mux *imux = &spec->private_imux[0];
3109         int i, err, idx = 0;
3110
3111         /* for internal loopback recording select */
3112         imux->items[imux->num_items].label = "Stereo Mixer";
3113         imux->items[imux->num_items].index = 3;
3114         imux->num_items++;
3115
3116         for (i = 0; i < AUTO_PIN_LAST; i++) {
3117                 if (!cfg->input_pins[i])
3118                         continue;
3119
3120                 switch (cfg->input_pins[i]) {
3121                 case 0x14: /* Mic */
3122                         idx = 1;
3123                         break;
3124
3125                 case 0x15: /* Line In */
3126                         idx = 2;
3127                         break;
3128
3129                 case 0x18: /* Front Mic */
3130                         idx = 3;
3131                         break;
3132                 }
3133                 err = via_new_analog_input(spec, cfg->input_pins[i],
3134                                            labels[i], idx, 0x1A);
3135                 if (err < 0)
3136                         return err;
3137                 imux->items[imux->num_items].label = labels[i];
3138                 imux->items[imux->num_items].index = idx-1;
3139                 imux->num_items++;
3140         }
3141         return 0;
3142 }
3143
3144 static int vt1702_parse_auto_config(struct hda_codec *codec)
3145 {
3146         struct via_spec *spec = codec->spec;
3147         int err;
3148         static hda_nid_t vt1702_ignore[] = {0x1C, 0};
3149
3150         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
3151                                            vt1702_ignore);
3152         if (err < 0)
3153                 return err;
3154         err = vt1702_auto_fill_dac_nids(spec, &spec->autocfg);
3155         if (err < 0)
3156                 return err;
3157         if (!spec->autocfg.line_outs && !spec->autocfg.hp_pins[0])
3158                 return 0; /* can't find valid BIOS pin config */
3159
3160         err = vt1702_auto_create_line_out_ctls(spec, &spec->autocfg);
3161         if (err < 0)
3162                 return err;
3163         err = vt1702_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
3164         if (err < 0)
3165                 return err;
3166         err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg);
3167         if (err < 0)
3168                 return err;
3169
3170         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3171
3172         if (spec->autocfg.dig_out_pin)
3173                 spec->multiout.dig_out_nid = VT1702_DIGOUT_NID;
3174
3175         spec->extra_dig_out_nid = 0x1B;
3176
3177         if (spec->kctl_alloc)
3178                 spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
3179
3180         spec->input_mux = &spec->private_imux[0];
3181
3182         if (spec->hp_mux)
3183                 spec->mixers[spec->num_mixers++] = via_hp_mixer;
3184
3185         return 1;
3186 }
3187
3188 #ifdef CONFIG_SND_HDA_POWER_SAVE
3189 static struct hda_amp_list vt1702_loopbacks[] = {
3190         { 0x1A, HDA_INPUT, 1 },
3191         { 0x1A, HDA_INPUT, 2 },
3192         { 0x1A, HDA_INPUT, 3 },
3193         { 0x1A, HDA_INPUT, 4 },
3194         { } /* end */
3195 };
3196 #endif
3197
3198 static int patch_vt1702(struct hda_codec *codec)
3199 {
3200         struct via_spec *spec;
3201         int err;
3202         unsigned int response;
3203         unsigned char control;
3204
3205         /* create a codec specific record */
3206         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
3207         if (spec == NULL)
3208                 return -ENOMEM;
3209
3210         codec->spec = spec;
3211
3212         /* automatic parse from the BIOS config */
3213         err = vt1702_parse_auto_config(codec);
3214         if (err < 0) {
3215                 via_free(codec);
3216                 return err;
3217         } else if (!err) {
3218                 printk(KERN_INFO "hda_codec: Cannot set up configuration "
3219                        "from BIOS.  Using genenic mode...\n");
3220         }
3221
3222         spec->init_verbs[spec->num_iverbs++] = vt1702_volume_init_verbs;
3223         spec->init_verbs[spec->num_iverbs++] = vt1702_uniwill_init_verbs;
3224
3225         spec->stream_name_analog = "VT1702 Analog";
3226         spec->stream_analog_playback = &vt1702_pcm_analog_playback;
3227         spec->stream_analog_capture = &vt1702_pcm_analog_capture;
3228
3229         spec->stream_name_digital = "VT1702 Digital";
3230         spec->stream_digital_playback = &vt1702_pcm_digital_playback;
3231
3232         if (!spec->adc_nids && spec->input_mux) {
3233                 spec->adc_nids = vt1702_adc_nids;
3234                 spec->num_adc_nids = ARRAY_SIZE(vt1702_adc_nids);
3235                 spec->mixers[spec->num_mixers] = vt1702_capture_mixer;
3236                 spec->num_mixers++;
3237         }
3238
3239         codec->patch_ops = via_patch_ops;
3240
3241         codec->patch_ops.init = via_auto_init;
3242         codec->patch_ops.unsol_event = via_unsol_event;
3243 #ifdef CONFIG_SND_HDA_POWER_SAVE
3244         spec->loopback.amplist = vt1702_loopbacks;
3245 #endif
3246
3247         /* Open backdoor */
3248         response = snd_hda_codec_read(codec, codec->afg, 0, 0xF8C, 0);
3249         control = (unsigned char)(response & 0xff);
3250         control |= 0x3;
3251         snd_hda_codec_write(codec,  codec->afg, 0, 0xF88, control);
3252
3253         /* Enable GPIO 0&1 for volume&mute control */
3254         /* Enable GPIO 2 for DMIC-DATA */
3255         response = snd_hda_codec_read(codec, codec->afg, 0, 0xF84, 0);
3256         control = (unsigned char)((response >> 16) & 0x3f);
3257         snd_hda_codec_write(codec,  codec->afg, 0, 0xF82, control);
3258
3259         return 0;
3260 }
3261
3262 /*
3263  * patch entries
3264  */
3265 struct hda_codec_preset snd_hda_preset_via[] = {
3266         { .id = 0x11061708, .name = "VIA VT1708", .patch = patch_vt1708},
3267         { .id = 0x11061709, .name = "VIA VT1708", .patch = patch_vt1708},
3268         { .id = 0x1106170A, .name = "VIA VT1708", .patch = patch_vt1708},
3269         { .id = 0x1106170B, .name = "VIA VT1708", .patch = patch_vt1708},
3270         { .id = 0x1106E710, .name = "VIA VT1709 10-Ch",
3271           .patch = patch_vt1709_10ch},
3272         { .id = 0x1106E711, .name = "VIA VT1709 10-Ch",
3273           .patch = patch_vt1709_10ch},
3274         { .id = 0x1106E712, .name = "VIA VT1709 10-Ch",
3275           .patch = patch_vt1709_10ch},
3276         { .id = 0x1106E713, .name = "VIA VT1709 10-Ch",
3277           .patch = patch_vt1709_10ch},
3278         { .id = 0x1106E714, .name = "VIA VT1709 6-Ch",
3279           .patch = patch_vt1709_6ch},
3280         { .id = 0x1106E715, .name = "VIA VT1709 6-Ch",
3281           .patch = patch_vt1709_6ch},
3282         { .id = 0x1106E716, .name = "VIA VT1709 6-Ch",
3283           .patch = patch_vt1709_6ch},
3284         { .id = 0x1106E717, .name = "VIA VT1709 6-Ch",
3285           .patch = patch_vt1709_6ch},
3286         { .id = 0x1106E720, .name = "VIA VT1708B 8-Ch",
3287           .patch = patch_vt1708B_8ch},
3288         { .id = 0x1106E721, .name = "VIA VT1708B 8-Ch",
3289           .patch = patch_vt1708B_8ch},
3290         { .id = 0x1106E722, .name = "VIA VT1708B 8-Ch",
3291           .patch = patch_vt1708B_8ch},
3292         { .id = 0x1106E723, .name = "VIA VT1708B 8-Ch",
3293           .patch = patch_vt1708B_8ch},
3294         { .id = 0x1106E724, .name = "VIA VT1708B 4-Ch",
3295           .patch = patch_vt1708B_4ch},
3296         { .id = 0x1106E725, .name = "VIA VT1708B 4-Ch",
3297           .patch = patch_vt1708B_4ch},
3298         { .id = 0x1106E726, .name = "VIA VT1708B 4-Ch",
3299           .patch = patch_vt1708B_4ch},
3300         { .id = 0x1106E727, .name = "VIA VT1708B 4-Ch",
3301           .patch = patch_vt1708B_4ch},
3302         { .id = 0x11060397, .name = "VIA VT1708S",
3303           .patch = patch_vt1708S},
3304         { .id = 0x11061397, .name = "VIA VT1708S",
3305           .patch = patch_vt1708S},
3306         { .id = 0x11062397, .name = "VIA VT1708S",
3307           .patch = patch_vt1708S},
3308         { .id = 0x11063397, .name = "VIA VT1708S",
3309           .patch = patch_vt1708S},
3310         { .id = 0x11064397, .name = "VIA VT1708S",
3311           .patch = patch_vt1708S},
3312         { .id = 0x11065397, .name = "VIA VT1708S",
3313           .patch = patch_vt1708S},
3314         { .id = 0x11066397, .name = "VIA VT1708S",
3315           .patch = patch_vt1708S},
3316         { .id = 0x11067397, .name = "VIA VT1708S",
3317           .patch = patch_vt1708S},
3318         { .id = 0x11060398, .name = "VIA VT1702",
3319           .patch = patch_vt1702},
3320         { .id = 0x11061398, .name = "VIA VT1702",
3321           .patch = patch_vt1702},
3322         { .id = 0x11062398, .name = "VIA VT1702",
3323           .patch = patch_vt1702},
3324         { .id = 0x11063398, .name = "VIA VT1702",
3325           .patch = patch_vt1702},
3326         { .id = 0x11064398, .name = "VIA VT1702",
3327           .patch = patch_vt1702},
3328         { .id = 0x11065398, .name = "VIA VT1702",
3329           .patch = patch_vt1702},
3330         { .id = 0x11066398, .name = "VIA VT1702",
3331           .patch = patch_vt1702},
3332         { .id = 0x11067398, .name = "VIA VT1702",
3333           .patch = patch_vt1702},
3334         {} /* terminator */
3335 };